PowerPC VLE insn set additions
[deliverable/binutils-gdb.git] / gdb / breakpoint.c
CommitLineData
c906108c 1/* Everything about breakpoints, for GDB.
8926118c 2
61baf725 3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
19
20#include "defs.h"
a6d9a66e 21#include "arch-utils.h"
c906108c 22#include <ctype.h>
776592bf 23#include "hashtab.h"
c906108c
SS
24#include "symtab.h"
25#include "frame.h"
26#include "breakpoint.h"
1042e4c0 27#include "tracepoint.h"
c906108c
SS
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"
45741a9c 35#include "infrun.h"
c906108c
SS
36#include "gdbthread.h"
37#include "target.h"
38#include "language.h"
50f182aa 39#include "gdb-demangle.h"
0ba1096a 40#include "filenames.h"
c906108c
SS
41#include "annotate.h"
42#include "symfile.h"
43#include "objfiles.h"
0378c332 44#include "source.h"
c5f0f3d0 45#include "linespec.h"
c94fdfd0 46#include "completer.h"
5b7f31a4 47#include "gdb.h"
8b93c638 48#include "ui-out.h"
e1507482 49#include "cli/cli-script.h"
fe898f56 50#include "block.h"
a77053c2 51#include "solib.h"
84acb35a
JJ
52#include "solist.h"
53#include "observer.h"
765dc015 54#include "memattr.h"
f7f9143b 55#include "ada-lang.h"
d1aa2f50 56#include "top.h"
79a45b7d 57#include "valprint.h"
4efc6507 58#include "jit.h"
65d79d4b 59#include "parser-defs.h"
55aa24fb
SDJ
60#include "gdb_regex.h"
61#include "probe.h"
e9cafbcc 62#include "cli/cli-utils.h"
be34f849 63#include "continuations.h"
1bfeeb0f
JL
64#include "stack.h"
65#include "skip.h"
b775012e 66#include "ax-gdb.h"
e2e4d78b 67#include "dummy-frame.h"
5589af0e 68#include "interps.h"
d3ce09f5 69#include "format.h"
cfc31633 70#include "thread-fsm.h"
5d5658a1 71#include "tid-parse.h"
d3ce09f5 72
1042e4c0
SS
73/* readline include files */
74#include "readline/readline.h"
75#include "readline/history.h"
76
77/* readline defines this. */
78#undef savestring
79
034dad6f 80#include "mi/mi-common.h"
6dddc817 81#include "extension.h"
325fac50 82#include <algorithm>
104c1213 83
e7e8980f
YQ
84/* Enums for exception-handling support. */
85enum exception_event_kind
86{
87 EX_EVENT_THROW,
591f19e8 88 EX_EVENT_RETHROW,
e7e8980f
YQ
89 EX_EVENT_CATCH
90};
91
4a64f543 92/* Prototypes for local functions. */
c906108c 93
a14ed312 94static void enable_delete_command (char *, int);
c906108c 95
a14ed312 96static void enable_once_command (char *, int);
c906108c 97
816338b5
SS
98static void enable_count_command (char *, int);
99
a14ed312 100static void disable_command (char *, int);
c906108c 101
a14ed312 102static void enable_command (char *, int);
c906108c 103
896b6bda
PA
104static void map_breakpoint_numbers (const char *,
105 void (*) (struct breakpoint *,
106 void *),
95a42b64 107 void *);
c906108c 108
a14ed312 109static void ignore_command (char *, int);
c906108c 110
4efb68b1 111static int breakpoint_re_set_one (void *);
c906108c 112
348d480f
PA
113static void breakpoint_re_set_default (struct breakpoint *);
114
f00aae0f
KS
115static void
116 create_sals_from_location_default (const struct event_location *location,
117 struct linespec_result *canonical,
118 enum bptype type_wanted);
983af33b
SDJ
119
120static void create_breakpoints_sal_default (struct gdbarch *,
121 struct linespec_result *,
e7e0cddf 122 char *, char *, enum bptype,
983af33b
SDJ
123 enum bpdisp, int, int,
124 int,
125 const struct breakpoint_ops *,
44f238bb 126 int, int, int, unsigned);
983af33b 127
f00aae0f
KS
128static void decode_location_default (struct breakpoint *b,
129 const struct event_location *location,
c2f4122d 130 struct program_space *search_pspace,
f00aae0f 131 struct symtabs_and_lines *sals);
983af33b 132
a14ed312 133static void clear_command (char *, int);
c906108c 134
a14ed312 135static void catch_command (char *, int);
c906108c 136
a9634178 137static int can_use_hardware_watchpoint (struct value *);
c906108c 138
98deb0da 139static void break_command_1 (char *, int, int);
c906108c 140
a14ed312 141static void mention (struct breakpoint *);
c906108c 142
348d480f
PA
143static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
144 enum bptype,
c0a91b2b 145 const struct breakpoint_ops *);
3742cc8b
YQ
146static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
147 const struct symtab_and_line *);
148
4a64f543
MS
149/* This function is used in gdbtk sources and thus can not be made
150 static. */
63c252f8 151struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
348d480f 152 struct symtab_and_line,
c0a91b2b
TT
153 enum bptype,
154 const struct breakpoint_ops *);
c906108c 155
06edf0c0
PA
156static struct breakpoint *
157 momentary_breakpoint_from_master (struct breakpoint *orig,
158 enum bptype type,
a1aa2221
LM
159 const struct breakpoint_ops *ops,
160 int loc_enabled);
06edf0c0 161
76897487
KB
162static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
163
a6d9a66e
UW
164static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
165 CORE_ADDR bpaddr,
88f7da05 166 enum bptype bptype);
76897487 167
6c95b8df
PA
168static void describe_other_breakpoints (struct gdbarch *,
169 struct program_space *, CORE_ADDR,
5af949e3 170 struct obj_section *, int);
c906108c 171
85d721b8
PA
172static int watchpoint_locations_match (struct bp_location *loc1,
173 struct bp_location *loc2);
174
f1310107
TJB
175static int breakpoint_location_address_match (struct bp_location *bl,
176 struct address_space *aspace,
177 CORE_ADDR addr);
178
d35ae833
PA
179static int breakpoint_location_address_range_overlap (struct bp_location *,
180 struct address_space *,
181 CORE_ADDR, int);
182
a14ed312 183static void breakpoints_info (char *, int);
c906108c 184
d77f58be
SS
185static void watchpoints_info (char *, int);
186
e5a67952
MS
187static int breakpoint_1 (char *, int,
188 int (*) (const struct breakpoint *));
c906108c 189
4efb68b1 190static int breakpoint_cond_eval (void *);
c906108c 191
4efb68b1 192static void cleanup_executing_breakpoints (void *);
c906108c 193
a14ed312 194static void commands_command (char *, int);
c906108c 195
a14ed312 196static void condition_command (char *, int);
c906108c 197
834c0d03 198static int remove_breakpoint (struct bp_location *);
b2b6a7da 199static int remove_breakpoint_1 (struct bp_location *, enum remove_bp_reason);
c906108c 200
e514a9d6 201static enum print_stop_action print_bp_stop_message (bpstat bs);
c906108c 202
4efb68b1 203static int watchpoint_check (void *);
c906108c 204
a14ed312 205static void maintenance_info_breakpoints (char *, int);
c906108c 206
a14ed312 207static int hw_breakpoint_used_count (void);
c906108c 208
a1398e0c
PA
209static int hw_watchpoint_use_count (struct breakpoint *);
210
211static int hw_watchpoint_used_count_others (struct breakpoint *except,
212 enum bptype type,
213 int *other_type_used);
c906108c 214
a14ed312 215static void hbreak_command (char *, int);
c906108c 216
a14ed312 217static void thbreak_command (char *, int);
c906108c 218
816338b5
SS
219static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
220 int count);
c906108c 221
a14ed312 222static void stop_command (char *arg, int from_tty);
7a292a7a 223
a14ed312 224static void stopin_command (char *arg, int from_tty);
7a292a7a 225
a14ed312 226static void stopat_command (char *arg, int from_tty);
7a292a7a 227
a14ed312 228static void tcatch_command (char *arg, int from_tty);
7a292a7a 229
fe3f5fa8 230static void free_bp_location (struct bp_location *loc);
f431efe5
PA
231static void incref_bp_location (struct bp_location *loc);
232static void decref_bp_location (struct bp_location **loc);
fe3f5fa8 233
39d61571 234static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
a5606eee 235
44702360
PA
236/* update_global_location_list's modes of operation wrt to whether to
237 insert locations now. */
238enum ugll_insert_mode
239{
240 /* Don't insert any breakpoint locations into the inferior, only
241 remove already-inserted locations that no longer should be
242 inserted. Functions that delete a breakpoint or breakpoints
243 should specify this mode, so that deleting a breakpoint doesn't
244 have the side effect of inserting the locations of other
245 breakpoints that are marked not-inserted, but should_be_inserted
246 returns true on them.
247
248 This behavior is useful is situations close to tear-down -- e.g.,
249 after an exec, while the target still has execution, but
250 breakpoint shadows of the previous executable image should *NOT*
251 be restored to the new image; or before detaching, where the
252 target still has execution and wants to delete breakpoints from
253 GDB's lists, and all breakpoints had already been removed from
254 the inferior. */
255 UGLL_DONT_INSERT,
256
a25a5a45
PA
257 /* May insert breakpoints iff breakpoints_should_be_inserted_now
258 claims breakpoints should be inserted now. */
04086b45
PA
259 UGLL_MAY_INSERT,
260
a25a5a45
PA
261 /* Insert locations now, irrespective of
262 breakpoints_should_be_inserted_now. E.g., say all threads are
263 stopped right now, and the user did "continue". We need to
264 insert breakpoints _before_ resuming the target, but
265 UGLL_MAY_INSERT wouldn't insert them, because
266 breakpoints_should_be_inserted_now returns false at that point,
267 as no thread is running yet. */
04086b45 268 UGLL_INSERT
44702360
PA
269};
270
271static void update_global_location_list (enum ugll_insert_mode);
a5606eee 272
44702360 273static void update_global_location_list_nothrow (enum ugll_insert_mode);
74960c60 274
d77f58be 275static int is_hardware_watchpoint (const struct breakpoint *bpt);
74960c60
VP
276
277static void insert_breakpoint_locations (void);
a5606eee 278
1042e4c0
SS
279static void tracepoints_info (char *, int);
280
281static void delete_trace_command (char *, int);
282
283static void enable_trace_command (char *, int);
284
285static void disable_trace_command (char *, int);
286
287static void trace_pass_command (char *, int);
288
558a9d82
YQ
289static void set_tracepoint_count (int num);
290
9c06b0b4
TJB
291static int is_masked_watchpoint (const struct breakpoint *b);
292
b775012e
LM
293static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
294
983af33b
SDJ
295/* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
296 otherwise. */
297
298static int strace_marker_p (struct breakpoint *b);
0fb4aa4b 299
2060206e
PA
300/* The breakpoint_ops structure to be inherited by all breakpoint_ops
301 that are implemented on top of software or hardware breakpoints
302 (user breakpoints, internal and momentary breakpoints, etc.). */
303static struct breakpoint_ops bkpt_base_breakpoint_ops;
304
305/* Internal breakpoints class type. */
06edf0c0 306static struct breakpoint_ops internal_breakpoint_ops;
2060206e
PA
307
308/* Momentary breakpoints class type. */
06edf0c0
PA
309static struct breakpoint_ops momentary_breakpoint_ops;
310
e2e4d78b
JK
311/* Momentary breakpoints for bp_longjmp and bp_exception class type. */
312static struct breakpoint_ops longjmp_breakpoint_ops;
313
2060206e
PA
314/* The breakpoint_ops structure to be used in regular user created
315 breakpoints. */
316struct breakpoint_ops bkpt_breakpoint_ops;
317
55aa24fb
SDJ
318/* Breakpoints set on probes. */
319static struct breakpoint_ops bkpt_probe_breakpoint_ops;
320
e7e0cddf 321/* Dynamic printf class type. */
c5867ab6 322struct breakpoint_ops dprintf_breakpoint_ops;
e7e0cddf 323
d3ce09f5
SS
324/* The style in which to perform a dynamic printf. This is a user
325 option because different output options have different tradeoffs;
326 if GDB does the printing, there is better error handling if there
327 is a problem with any of the arguments, but using an inferior
328 function lets you have special-purpose printers and sending of
329 output to the same place as compiled-in print functions. */
330
331static const char dprintf_style_gdb[] = "gdb";
332static const char dprintf_style_call[] = "call";
333static const char dprintf_style_agent[] = "agent";
334static const char *const dprintf_style_enums[] = {
335 dprintf_style_gdb,
336 dprintf_style_call,
337 dprintf_style_agent,
338 NULL
339};
340static const char *dprintf_style = dprintf_style_gdb;
341
342/* The function to use for dynamic printf if the preferred style is to
343 call into the inferior. The value is simply a string that is
344 copied into the command, so it can be anything that GDB can
345 evaluate to a callable address, not necessarily a function name. */
346
bde6261a 347static char *dprintf_function;
d3ce09f5
SS
348
349/* The channel to use for dynamic printf if the preferred style is to
350 call into the inferior; if a nonempty string, it will be passed to
351 the call as the first argument, with the format string as the
352 second. As with the dprintf function, this can be anything that
353 GDB knows how to evaluate, so in addition to common choices like
354 "stderr", this could be an app-specific expression like
355 "mystreams[curlogger]". */
356
bde6261a 357static char *dprintf_channel;
d3ce09f5
SS
358
359/* True if dprintf commands should continue to operate even if GDB
360 has disconnected. */
361static int disconnected_dprintf = 1;
362
5cea2a26
PA
363/* A reference-counted struct command_line. This lets multiple
364 breakpoints share a single command list. */
365struct counted_command_line
366{
367 /* The reference count. */
368 int refc;
369
370 /* The command list. */
371 struct command_line *commands;
372};
373
374struct command_line *
375breakpoint_commands (struct breakpoint *b)
376{
377 return b->commands ? b->commands->commands : NULL;
378}
3daf8fe5 379
f3b1572e
PA
380/* Flag indicating that a command has proceeded the inferior past the
381 current breakpoint. */
382
383static int breakpoint_proceeded;
384
956a9fb9 385const char *
2cec12e5
AR
386bpdisp_text (enum bpdisp disp)
387{
4a64f543
MS
388 /* NOTE: the following values are a part of MI protocol and
389 represent values of 'disp' field returned when inferior stops at
390 a breakpoint. */
bc043ef3 391 static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
cc59ec59 392
2cec12e5
AR
393 return bpdisps[(int) disp];
394}
c906108c 395
4a64f543 396/* Prototypes for exported functions. */
c906108c 397/* If FALSE, gdb will not use hardware support for watchpoints, even
4a64f543 398 if such is available. */
c906108c
SS
399static int can_use_hw_watchpoints;
400
920d2a44
AC
401static void
402show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
403 struct cmd_list_element *c,
404 const char *value)
405{
3e43a32a
MS
406 fprintf_filtered (file,
407 _("Debugger's willingness to use "
408 "watchpoint hardware is %s.\n"),
920d2a44
AC
409 value);
410}
411
fa8d40ab
JJ
412/* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
413 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
4a64f543 414 for unrecognized breakpoint locations.
fa8d40ab
JJ
415 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
416static enum auto_boolean pending_break_support;
920d2a44
AC
417static void
418show_pending_break_support (struct ui_file *file, int from_tty,
419 struct cmd_list_element *c,
420 const char *value)
421{
3e43a32a
MS
422 fprintf_filtered (file,
423 _("Debugger's behavior regarding "
424 "pending breakpoints is %s.\n"),
920d2a44
AC
425 value);
426}
fa8d40ab 427
765dc015 428/* If 1, gdb will automatically use hardware breakpoints for breakpoints
4a64f543 429 set with "break" but falling in read-only memory.
765dc015
VP
430 If 0, gdb will warn about such breakpoints, but won't automatically
431 use hardware breakpoints. */
432static int automatic_hardware_breakpoints;
433static void
434show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
435 struct cmd_list_element *c,
436 const char *value)
437{
3e43a32a
MS
438 fprintf_filtered (file,
439 _("Automatic usage of hardware breakpoints is %s.\n"),
765dc015
VP
440 value);
441}
442
a25a5a45
PA
443/* If on, GDB keeps breakpoints inserted even if the inferior is
444 stopped, and immediately inserts any new breakpoints as soon as
445 they're created. If off (default), GDB keeps breakpoints off of
446 the target as long as possible. That is, it delays inserting
447 breakpoints until the next resume, and removes them again when the
448 target fully stops. This is a bit safer in case GDB crashes while
449 processing user input. */
450static int always_inserted_mode = 0;
72d0e2c5 451
33e5cbd6 452static void
74960c60 453show_always_inserted_mode (struct ui_file *file, int from_tty,
33e5cbd6 454 struct cmd_list_element *c, const char *value)
74960c60 455{
a25a5a45
PA
456 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
457 value);
74960c60
VP
458}
459
b57bacec
PA
460/* See breakpoint.h. */
461
33e5cbd6 462int
a25a5a45 463breakpoints_should_be_inserted_now (void)
33e5cbd6 464{
a25a5a45
PA
465 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
466 {
467 /* If breakpoints are global, they should be inserted even if no
468 thread under gdb's control is running, or even if there are
469 no threads under GDB's control yet. */
470 return 1;
471 }
472 else if (target_has_execution)
473 {
372316f1
PA
474 struct thread_info *tp;
475
a25a5a45
PA
476 if (always_inserted_mode)
477 {
478 /* The user wants breakpoints inserted even if all threads
479 are stopped. */
480 return 1;
481 }
482
b57bacec
PA
483 if (threads_are_executing ())
484 return 1;
372316f1
PA
485
486 /* Don't remove breakpoints yet if, even though all threads are
487 stopped, we still have events to process. */
488 ALL_NON_EXITED_THREADS (tp)
489 if (tp->resumed
490 && tp->suspend.waitstatus_pending_p)
491 return 1;
a25a5a45
PA
492 }
493 return 0;
33e5cbd6 494}
765dc015 495
b775012e
LM
496static const char condition_evaluation_both[] = "host or target";
497
498/* Modes for breakpoint condition evaluation. */
499static const char condition_evaluation_auto[] = "auto";
500static const char condition_evaluation_host[] = "host";
501static const char condition_evaluation_target[] = "target";
502static const char *const condition_evaluation_enums[] = {
503 condition_evaluation_auto,
504 condition_evaluation_host,
505 condition_evaluation_target,
506 NULL
507};
508
509/* Global that holds the current mode for breakpoint condition evaluation. */
510static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
511
512/* Global that we use to display information to the user (gets its value from
513 condition_evaluation_mode_1. */
514static const char *condition_evaluation_mode = condition_evaluation_auto;
515
516/* Translate a condition evaluation mode MODE into either "host"
517 or "target". This is used mostly to translate from "auto" to the
518 real setting that is being used. It returns the translated
519 evaluation mode. */
520
521static const char *
522translate_condition_evaluation_mode (const char *mode)
523{
524 if (mode == condition_evaluation_auto)
525 {
526 if (target_supports_evaluation_of_breakpoint_conditions ())
527 return condition_evaluation_target;
528 else
529 return condition_evaluation_host;
530 }
531 else
532 return mode;
533}
534
535/* Discovers what condition_evaluation_auto translates to. */
536
537static const char *
538breakpoint_condition_evaluation_mode (void)
539{
540 return translate_condition_evaluation_mode (condition_evaluation_mode);
541}
542
543/* Return true if GDB should evaluate breakpoint conditions or false
544 otherwise. */
545
546static int
547gdb_evaluates_breakpoint_condition_p (void)
548{
549 const char *mode = breakpoint_condition_evaluation_mode ();
550
551 return (mode == condition_evaluation_host);
552}
553
a14ed312 554void _initialize_breakpoint (void);
c906108c 555
c906108c
SS
556/* Are we executing breakpoint commands? */
557static int executing_breakpoint_commands;
558
c02f5703
MS
559/* Are overlay event breakpoints enabled? */
560static int overlay_events_enabled;
561
e09342b5
TJB
562/* See description in breakpoint.h. */
563int target_exact_watchpoints = 0;
564
c906108c 565/* Walk the following statement or block through all breakpoints.
e5dd4106 566 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
4a64f543 567 current breakpoint. */
c906108c 568
5c44784c 569#define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
c906108c 570
5c44784c
JM
571#define ALL_BREAKPOINTS_SAFE(B,TMP) \
572 for (B = breakpoint_chain; \
573 B ? (TMP=B->next, 1): 0; \
574 B = TMP)
c906108c 575
4a64f543
MS
576/* Similar iterator for the low-level breakpoints. SAFE variant is
577 not provided so update_global_location_list must not be called
578 while executing the block of ALL_BP_LOCATIONS. */
7cc221ef 579
876fa593 580#define ALL_BP_LOCATIONS(B,BP_TMP) \
f5336ca5
PA
581 for (BP_TMP = bp_locations; \
582 BP_TMP < bp_locations + bp_locations_count && (B = *BP_TMP);\
876fa593 583 BP_TMP++)
7cc221ef 584
b775012e
LM
585/* Iterates through locations with address ADDRESS for the currently selected
586 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
587 to where the loop should start from.
588 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
589 appropriate location to start with. */
590
591#define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
592 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
593 BP_LOCP_TMP = BP_LOCP_START; \
594 BP_LOCP_START \
f5336ca5 595 && (BP_LOCP_TMP < bp_locations + bp_locations_count \
b775012e
LM
596 && (*BP_LOCP_TMP)->address == ADDRESS); \
597 BP_LOCP_TMP++)
598
1042e4c0
SS
599/* Iterator for tracepoints only. */
600
601#define ALL_TRACEPOINTS(B) \
602 for (B = breakpoint_chain; B; B = B->next) \
d77f58be 603 if (is_tracepoint (B))
1042e4c0 604
7cc221ef 605/* Chains of all breakpoints defined. */
c906108c
SS
606
607struct breakpoint *breakpoint_chain;
608
f5336ca5 609/* Array is sorted by bp_locations_compare - primarily by the ADDRESS. */
876fa593 610
f5336ca5 611static struct bp_location **bp_locations;
876fa593 612
f5336ca5 613/* Number of elements of BP_LOCATIONS. */
876fa593 614
f5336ca5 615static unsigned bp_locations_count;
876fa593 616
4a64f543 617/* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
f5336ca5 618 ADDRESS for the current elements of BP_LOCATIONS which get a valid
4a64f543 619 result from bp_location_has_shadow. You can use it for roughly
f5336ca5 620 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
4a64f543 621 an address you need to read. */
876fa593 622
f5336ca5 623static CORE_ADDR bp_locations_placed_address_before_address_max;
876fa593 624
4a64f543
MS
625/* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
626 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
f5336ca5
PA
627 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
628 You can use it for roughly limiting the subrange of BP_LOCATIONS to
4a64f543 629 scan for shadow bytes for an address you need to read. */
876fa593 630
f5336ca5 631static CORE_ADDR bp_locations_shadow_len_after_address_max;
7cc221ef 632
4a64f543 633/* The locations that no longer correspond to any breakpoint, unlinked
f5336ca5
PA
634 from the bp_locations array, but for which a hit may still be
635 reported by a target. */
20874c92
VP
636VEC(bp_location_p) *moribund_locations = NULL;
637
c906108c
SS
638/* Number of last breakpoint made. */
639
95a42b64
TT
640static int breakpoint_count;
641
86b17b60
PA
642/* The value of `breakpoint_count' before the last command that
643 created breakpoints. If the last (break-like) command created more
644 than one breakpoint, then the difference between BREAKPOINT_COUNT
645 and PREV_BREAKPOINT_COUNT is more than one. */
646static int prev_breakpoint_count;
c906108c 647
1042e4c0
SS
648/* Number of last tracepoint made. */
649
95a42b64 650static int tracepoint_count;
1042e4c0 651
6149aea9
PA
652static struct cmd_list_element *breakpoint_set_cmdlist;
653static struct cmd_list_element *breakpoint_show_cmdlist;
9291a0cd 654struct cmd_list_element *save_cmdlist;
6149aea9 655
badd37ce
SDJ
656/* See declaration at breakpoint.h. */
657
658struct breakpoint *
659breakpoint_find_if (int (*func) (struct breakpoint *b, void *d),
660 void *user_data)
661{
662 struct breakpoint *b = NULL;
663
664 ALL_BREAKPOINTS (b)
665 {
666 if (func (b, user_data) != 0)
667 break;
668 }
669
670 return b;
671}
672
468d015d
JJ
673/* Return whether a breakpoint is an active enabled breakpoint. */
674static int
675breakpoint_enabled (struct breakpoint *b)
676{
0d381245 677 return (b->enable_state == bp_enabled);
468d015d
JJ
678}
679
c906108c
SS
680/* Set breakpoint count to NUM. */
681
95a42b64 682static void
fba45db2 683set_breakpoint_count (int num)
c906108c 684{
86b17b60 685 prev_breakpoint_count = breakpoint_count;
c906108c 686 breakpoint_count = num;
4fa62494 687 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
c906108c
SS
688}
689
86b17b60
PA
690/* Used by `start_rbreak_breakpoints' below, to record the current
691 breakpoint count before "rbreak" creates any breakpoint. */
692static int rbreak_start_breakpoint_count;
693
95a42b64
TT
694/* Called at the start an "rbreak" command to record the first
695 breakpoint made. */
86b17b60 696
95a42b64
TT
697void
698start_rbreak_breakpoints (void)
699{
86b17b60 700 rbreak_start_breakpoint_count = breakpoint_count;
95a42b64
TT
701}
702
703/* Called at the end of an "rbreak" command to record the last
704 breakpoint made. */
86b17b60 705
95a42b64
TT
706void
707end_rbreak_breakpoints (void)
708{
86b17b60 709 prev_breakpoint_count = rbreak_start_breakpoint_count;
95a42b64
TT
710}
711
4a64f543 712/* Used in run_command to zero the hit count when a new run starts. */
c906108c
SS
713
714void
fba45db2 715clear_breakpoint_hit_counts (void)
c906108c
SS
716{
717 struct breakpoint *b;
718
719 ALL_BREAKPOINTS (b)
720 b->hit_count = 0;
721}
722
9add0f1b
TT
723/* Allocate a new counted_command_line with reference count of 1.
724 The new structure owns COMMANDS. */
725
726static struct counted_command_line *
727alloc_counted_command_line (struct command_line *commands)
728{
8d749320 729 struct counted_command_line *result = XNEW (struct counted_command_line);
cc59ec59 730
9add0f1b
TT
731 result->refc = 1;
732 result->commands = commands;
8d749320 733
9add0f1b
TT
734 return result;
735}
736
737/* Increment reference count. This does nothing if CMD is NULL. */
738
739static void
740incref_counted_command_line (struct counted_command_line *cmd)
741{
742 if (cmd)
743 ++cmd->refc;
744}
745
746/* Decrement reference count. If the reference count reaches 0,
747 destroy the counted_command_line. Sets *CMDP to NULL. This does
748 nothing if *CMDP is NULL. */
749
750static void
751decref_counted_command_line (struct counted_command_line **cmdp)
752{
753 if (*cmdp)
754 {
755 if (--(*cmdp)->refc == 0)
756 {
757 free_command_lines (&(*cmdp)->commands);
758 xfree (*cmdp);
759 }
760 *cmdp = NULL;
761 }
762}
763
764/* A cleanup function that calls decref_counted_command_line. */
765
766static void
767do_cleanup_counted_command_line (void *arg)
768{
9a3c8263 769 decref_counted_command_line ((struct counted_command_line **) arg);
9add0f1b
TT
770}
771
772/* Create a cleanup that calls decref_counted_command_line on the
773 argument. */
774
775static struct cleanup *
776make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
777{
778 return make_cleanup (do_cleanup_counted_command_line, cmdp);
779}
780
c906108c 781\f
48cb2d85
VP
782/* Return the breakpoint with the specified number, or NULL
783 if the number does not refer to an existing breakpoint. */
784
785struct breakpoint *
786get_breakpoint (int num)
787{
788 struct breakpoint *b;
789
790 ALL_BREAKPOINTS (b)
791 if (b->number == num)
792 return b;
793
794 return NULL;
795}
5c44784c 796
c906108c 797\f
adc36818 798
b775012e
LM
799/* Mark locations as "conditions have changed" in case the target supports
800 evaluating conditions on its side. */
801
802static void
803mark_breakpoint_modified (struct breakpoint *b)
804{
805 struct bp_location *loc;
806
807 /* This is only meaningful if the target is
808 evaluating conditions and if the user has
809 opted for condition evaluation on the target's
810 side. */
811 if (gdb_evaluates_breakpoint_condition_p ()
812 || !target_supports_evaluation_of_breakpoint_conditions ())
813 return;
814
815 if (!is_breakpoint (b))
816 return;
817
818 for (loc = b->loc; loc; loc = loc->next)
819 loc->condition_changed = condition_modified;
820}
821
822/* Mark location as "conditions have changed" in case the target supports
823 evaluating conditions on its side. */
824
825static void
826mark_breakpoint_location_modified (struct bp_location *loc)
827{
828 /* This is only meaningful if the target is
829 evaluating conditions and if the user has
830 opted for condition evaluation on the target's
831 side. */
832 if (gdb_evaluates_breakpoint_condition_p ()
833 || !target_supports_evaluation_of_breakpoint_conditions ())
834
835 return;
836
837 if (!is_breakpoint (loc->owner))
838 return;
839
840 loc->condition_changed = condition_modified;
841}
842
843/* Sets the condition-evaluation mode using the static global
844 condition_evaluation_mode. */
845
846static void
847set_condition_evaluation_mode (char *args, int from_tty,
848 struct cmd_list_element *c)
849{
b775012e
LM
850 const char *old_mode, *new_mode;
851
852 if ((condition_evaluation_mode_1 == condition_evaluation_target)
853 && !target_supports_evaluation_of_breakpoint_conditions ())
854 {
855 condition_evaluation_mode_1 = condition_evaluation_mode;
856 warning (_("Target does not support breakpoint condition evaluation.\n"
857 "Using host evaluation mode instead."));
858 return;
859 }
860
861 new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
862 old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
863
abf1152a
JK
864 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
865 settings was "auto". */
866 condition_evaluation_mode = condition_evaluation_mode_1;
867
b775012e
LM
868 /* Only update the mode if the user picked a different one. */
869 if (new_mode != old_mode)
870 {
871 struct bp_location *loc, **loc_tmp;
872 /* If the user switched to a different evaluation mode, we
873 need to synch the changes with the target as follows:
874
875 "host" -> "target": Send all (valid) conditions to the target.
876 "target" -> "host": Remove all the conditions from the target.
877 */
878
b775012e
LM
879 if (new_mode == condition_evaluation_target)
880 {
881 /* Mark everything modified and synch conditions with the
882 target. */
883 ALL_BP_LOCATIONS (loc, loc_tmp)
884 mark_breakpoint_location_modified (loc);
885 }
886 else
887 {
888 /* Manually mark non-duplicate locations to synch conditions
889 with the target. We do this to remove all the conditions the
890 target knows about. */
891 ALL_BP_LOCATIONS (loc, loc_tmp)
892 if (is_breakpoint (loc->owner) && loc->inserted)
893 loc->needs_update = 1;
894 }
895
896 /* Do the update. */
44702360 897 update_global_location_list (UGLL_MAY_INSERT);
b775012e
LM
898 }
899
900 return;
901}
902
903/* Shows the current mode of breakpoint condition evaluation. Explicitly shows
904 what "auto" is translating to. */
905
906static void
907show_condition_evaluation_mode (struct ui_file *file, int from_tty,
908 struct cmd_list_element *c, const char *value)
909{
910 if (condition_evaluation_mode == condition_evaluation_auto)
911 fprintf_filtered (file,
912 _("Breakpoint condition evaluation "
913 "mode is %s (currently %s).\n"),
914 value,
915 breakpoint_condition_evaluation_mode ());
916 else
917 fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
918 value);
919}
920
921/* A comparison function for bp_location AP and BP that is used by
922 bsearch. This comparison function only cares about addresses, unlike
f5336ca5 923 the more general bp_locations_compare function. */
b775012e
LM
924
925static int
f5336ca5 926bp_locations_compare_addrs (const void *ap, const void *bp)
b775012e 927{
9a3c8263
SM
928 const struct bp_location *a = *(const struct bp_location **) ap;
929 const struct bp_location *b = *(const struct bp_location **) bp;
b775012e
LM
930
931 if (a->address == b->address)
932 return 0;
933 else
934 return ((a->address > b->address) - (a->address < b->address));
935}
936
937/* Helper function to skip all bp_locations with addresses
938 less than ADDRESS. It returns the first bp_location that
939 is greater than or equal to ADDRESS. If none is found, just
940 return NULL. */
941
942static struct bp_location **
943get_first_locp_gte_addr (CORE_ADDR address)
944{
945 struct bp_location dummy_loc;
946 struct bp_location *dummy_locp = &dummy_loc;
947 struct bp_location **locp_found = NULL;
948
949 /* Initialize the dummy location's address field. */
950 memset (&dummy_loc, 0, sizeof (struct bp_location));
951 dummy_loc.address = address;
952
953 /* Find a close match to the first location at ADDRESS. */
9a3c8263 954 locp_found = ((struct bp_location **)
f5336ca5 955 bsearch (&dummy_locp, bp_locations, bp_locations_count,
9a3c8263 956 sizeof (struct bp_location **),
f5336ca5 957 bp_locations_compare_addrs));
b775012e
LM
958
959 /* Nothing was found, nothing left to do. */
960 if (locp_found == NULL)
961 return NULL;
962
963 /* We may have found a location that is at ADDRESS but is not the first in the
964 location's list. Go backwards (if possible) and locate the first one. */
f5336ca5 965 while ((locp_found - 1) >= bp_locations
b775012e
LM
966 && (*(locp_found - 1))->address == address)
967 locp_found--;
968
969 return locp_found;
970}
971
adc36818 972void
7a26bd4d 973set_breakpoint_condition (struct breakpoint *b, const char *exp,
adc36818
PM
974 int from_tty)
975{
3a5c3e22
PA
976 xfree (b->cond_string);
977 b->cond_string = NULL;
adc36818 978
3a5c3e22 979 if (is_watchpoint (b))
adc36818 980 {
3a5c3e22
PA
981 struct watchpoint *w = (struct watchpoint *) b;
982
4d01a485 983 w->cond_exp.reset ();
3a5c3e22
PA
984 }
985 else
986 {
987 struct bp_location *loc;
988
989 for (loc = b->loc; loc; loc = loc->next)
990 {
4d01a485 991 loc->cond.reset ();
b775012e
LM
992
993 /* No need to free the condition agent expression
994 bytecode (if we have one). We will handle this
995 when we go through update_global_location_list. */
3a5c3e22 996 }
adc36818 997 }
adc36818
PM
998
999 if (*exp == 0)
1000 {
1001 if (from_tty)
1002 printf_filtered (_("Breakpoint %d now unconditional.\n"), b->number);
1003 }
1004 else
1005 {
bbc13ae3 1006 const char *arg = exp;
cc59ec59 1007
adc36818
PM
1008 /* I don't know if it matters whether this is the string the user
1009 typed in or the decompiled expression. */
1010 b->cond_string = xstrdup (arg);
1011 b->condition_not_parsed = 0;
1012
1013 if (is_watchpoint (b))
1014 {
3a5c3e22
PA
1015 struct watchpoint *w = (struct watchpoint *) b;
1016
adc36818
PM
1017 innermost_block = NULL;
1018 arg = exp;
1bb9788d 1019 w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
adc36818
PM
1020 if (*arg)
1021 error (_("Junk at end of expression"));
3a5c3e22 1022 w->cond_exp_valid_block = innermost_block;
adc36818
PM
1023 }
1024 else
1025 {
3a5c3e22
PA
1026 struct bp_location *loc;
1027
adc36818
PM
1028 for (loc = b->loc; loc; loc = loc->next)
1029 {
1030 arg = exp;
1031 loc->cond =
1bb9788d
TT
1032 parse_exp_1 (&arg, loc->address,
1033 block_for_pc (loc->address), 0);
adc36818
PM
1034 if (*arg)
1035 error (_("Junk at end of expression"));
1036 }
1037 }
1038 }
b775012e
LM
1039 mark_breakpoint_modified (b);
1040
8d3788bd 1041 observer_notify_breakpoint_modified (b);
adc36818
PM
1042}
1043
d55637df
TT
1044/* Completion for the "condition" command. */
1045
1046static VEC (char_ptr) *
6f937416
PA
1047condition_completer (struct cmd_list_element *cmd,
1048 const char *text, const char *word)
d55637df 1049{
6f937416 1050 const char *space;
d55637df 1051
6f937416
PA
1052 text = skip_spaces_const (text);
1053 space = skip_to_space_const (text);
d55637df
TT
1054 if (*space == '\0')
1055 {
1056 int len;
1057 struct breakpoint *b;
1058 VEC (char_ptr) *result = NULL;
1059
1060 if (text[0] == '$')
1061 {
1062 /* We don't support completion of history indices. */
1063 if (isdigit (text[1]))
1064 return NULL;
1065 return complete_internalvar (&text[1]);
1066 }
1067
1068 /* We're completing the breakpoint number. */
1069 len = strlen (text);
1070
1071 ALL_BREAKPOINTS (b)
58ce7251
SDJ
1072 {
1073 char number[50];
1074
1075 xsnprintf (number, sizeof (number), "%d", b->number);
1076
1077 if (strncmp (number, text, len) == 0)
1078 VEC_safe_push (char_ptr, result, xstrdup (number));
1079 }
d55637df
TT
1080
1081 return result;
1082 }
1083
1084 /* We're completing the expression part. */
6f937416 1085 text = skip_spaces_const (space);
d55637df
TT
1086 return expression_completer (cmd, text, word);
1087}
1088
c906108c
SS
1089/* condition N EXP -- set break condition of breakpoint N to EXP. */
1090
1091static void
fba45db2 1092condition_command (char *arg, int from_tty)
c906108c 1093{
52f0bd74 1094 struct breakpoint *b;
c906108c 1095 char *p;
52f0bd74 1096 int bnum;
c906108c
SS
1097
1098 if (arg == 0)
e2e0b3e5 1099 error_no_arg (_("breakpoint number"));
c906108c
SS
1100
1101 p = arg;
1102 bnum = get_number (&p);
5c44784c 1103 if (bnum == 0)
8a3fe4f8 1104 error (_("Bad breakpoint argument: '%s'"), arg);
c906108c
SS
1105
1106 ALL_BREAKPOINTS (b)
1107 if (b->number == bnum)
2f069f6f 1108 {
6dddc817
DE
1109 /* Check if this breakpoint has a "stop" method implemented in an
1110 extension language. This method and conditions entered into GDB
1111 from the CLI are mutually exclusive. */
1112 const struct extension_language_defn *extlang
1113 = get_breakpoint_cond_ext_lang (b, EXT_LANG_NONE);
1114
1115 if (extlang != NULL)
1116 {
1117 error (_("Only one stop condition allowed. There is currently"
1118 " a %s stop condition defined for this breakpoint."),
1119 ext_lang_capitalized_name (extlang));
1120 }
2566ad2d 1121 set_breakpoint_condition (b, p, from_tty);
b775012e
LM
1122
1123 if (is_breakpoint (b))
44702360 1124 update_global_location_list (UGLL_MAY_INSERT);
b775012e 1125
2f069f6f
JB
1126 return;
1127 }
c906108c 1128
8a3fe4f8 1129 error (_("No breakpoint number %d."), bnum);
c906108c
SS
1130}
1131
a7bdde9e
VP
1132/* Check that COMMAND do not contain commands that are suitable
1133 only for tracepoints and not suitable for ordinary breakpoints.
4a64f543
MS
1134 Throw if any such commands is found. */
1135
a7bdde9e
VP
1136static void
1137check_no_tracepoint_commands (struct command_line *commands)
1138{
1139 struct command_line *c;
cc59ec59 1140
a7bdde9e
VP
1141 for (c = commands; c; c = c->next)
1142 {
1143 int i;
1144
1145 if (c->control_type == while_stepping_control)
3e43a32a
MS
1146 error (_("The 'while-stepping' command can "
1147 "only be used for tracepoints"));
a7bdde9e
VP
1148
1149 for (i = 0; i < c->body_count; ++i)
1150 check_no_tracepoint_commands ((c->body_list)[i]);
1151
1152 /* Not that command parsing removes leading whitespace and comment
4a64f543 1153 lines and also empty lines. So, we only need to check for
a7bdde9e
VP
1154 command directly. */
1155 if (strstr (c->line, "collect ") == c->line)
1156 error (_("The 'collect' command can only be used for tracepoints"));
1157
51661e93
VP
1158 if (strstr (c->line, "teval ") == c->line)
1159 error (_("The 'teval' command can only be used for tracepoints"));
a7bdde9e
VP
1160 }
1161}
1162
d77f58be
SS
1163/* Encapsulate tests for different types of tracepoints. */
1164
d9b3f62e
PA
1165static int
1166is_tracepoint_type (enum bptype type)
1167{
1168 return (type == bp_tracepoint
1169 || type == bp_fast_tracepoint
1170 || type == bp_static_tracepoint);
1171}
1172
a7bdde9e 1173int
d77f58be 1174is_tracepoint (const struct breakpoint *b)
a7bdde9e 1175{
d9b3f62e 1176 return is_tracepoint_type (b->type);
a7bdde9e 1177}
d9b3f62e 1178
e5dd4106 1179/* A helper function that validates that COMMANDS are valid for a
95a42b64
TT
1180 breakpoint. This function will throw an exception if a problem is
1181 found. */
48cb2d85 1182
95a42b64
TT
1183static void
1184validate_commands_for_breakpoint (struct breakpoint *b,
1185 struct command_line *commands)
48cb2d85 1186{
d77f58be 1187 if (is_tracepoint (b))
a7bdde9e 1188 {
c9a6ce02 1189 struct tracepoint *t = (struct tracepoint *) b;
a7bdde9e
VP
1190 struct command_line *c;
1191 struct command_line *while_stepping = 0;
c9a6ce02
PA
1192
1193 /* Reset the while-stepping step count. The previous commands
1194 might have included a while-stepping action, while the new
1195 ones might not. */
1196 t->step_count = 0;
1197
1198 /* We need to verify that each top-level element of commands is
1199 valid for tracepoints, that there's at most one
1200 while-stepping element, and that the while-stepping's body
1201 has valid tracing commands excluding nested while-stepping.
1202 We also need to validate the tracepoint action line in the
1203 context of the tracepoint --- validate_actionline actually
1204 has side effects, like setting the tracepoint's
1205 while-stepping STEP_COUNT, in addition to checking if the
1206 collect/teval actions parse and make sense in the
1207 tracepoint's context. */
a7bdde9e
VP
1208 for (c = commands; c; c = c->next)
1209 {
a7bdde9e
VP
1210 if (c->control_type == while_stepping_control)
1211 {
1212 if (b->type == bp_fast_tracepoint)
3e43a32a
MS
1213 error (_("The 'while-stepping' command "
1214 "cannot be used for fast tracepoint"));
0fb4aa4b 1215 else if (b->type == bp_static_tracepoint)
3e43a32a
MS
1216 error (_("The 'while-stepping' command "
1217 "cannot be used for static tracepoint"));
a7bdde9e
VP
1218
1219 if (while_stepping)
3e43a32a
MS
1220 error (_("The 'while-stepping' command "
1221 "can be used only once"));
a7bdde9e
VP
1222 else
1223 while_stepping = c;
1224 }
c9a6ce02
PA
1225
1226 validate_actionline (c->line, b);
a7bdde9e
VP
1227 }
1228 if (while_stepping)
1229 {
1230 struct command_line *c2;
1231
1232 gdb_assert (while_stepping->body_count == 1);
1233 c2 = while_stepping->body_list[0];
1234 for (; c2; c2 = c2->next)
1235 {
a7bdde9e
VP
1236 if (c2->control_type == while_stepping_control)
1237 error (_("The 'while-stepping' command cannot be nested"));
1238 }
1239 }
1240 }
1241 else
1242 {
1243 check_no_tracepoint_commands (commands);
1244 }
95a42b64
TT
1245}
1246
0fb4aa4b
PA
1247/* Return a vector of all the static tracepoints set at ADDR. The
1248 caller is responsible for releasing the vector. */
1249
1250VEC(breakpoint_p) *
1251static_tracepoints_here (CORE_ADDR addr)
1252{
1253 struct breakpoint *b;
1254 VEC(breakpoint_p) *found = 0;
1255 struct bp_location *loc;
1256
1257 ALL_BREAKPOINTS (b)
1258 if (b->type == bp_static_tracepoint)
1259 {
1260 for (loc = b->loc; loc; loc = loc->next)
1261 if (loc->address == addr)
1262 VEC_safe_push(breakpoint_p, found, b);
1263 }
1264
1265 return found;
1266}
1267
95a42b64 1268/* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
4a64f543 1269 validate that only allowed commands are included. */
95a42b64
TT
1270
1271void
4a64f543 1272breakpoint_set_commands (struct breakpoint *b,
93921405 1273 command_line_up &&commands)
95a42b64 1274{
93921405 1275 validate_commands_for_breakpoint (b, commands.get ());
a7bdde9e 1276
9add0f1b 1277 decref_counted_command_line (&b->commands);
93921405 1278 b->commands = alloc_counted_command_line (commands.release ());
8d3788bd 1279 observer_notify_breakpoint_modified (b);
48cb2d85
VP
1280}
1281
45a43567
TT
1282/* Set the internal `silent' flag on the breakpoint. Note that this
1283 is not the same as the "silent" that may appear in the breakpoint's
1284 commands. */
1285
1286void
1287breakpoint_set_silent (struct breakpoint *b, int silent)
1288{
1289 int old_silent = b->silent;
1290
1291 b->silent = silent;
1292 if (old_silent != silent)
8d3788bd 1293 observer_notify_breakpoint_modified (b);
45a43567
TT
1294}
1295
1296/* Set the thread for this breakpoint. If THREAD is -1, make the
1297 breakpoint work for any thread. */
1298
1299void
1300breakpoint_set_thread (struct breakpoint *b, int thread)
1301{
1302 int old_thread = b->thread;
1303
1304 b->thread = thread;
1305 if (old_thread != thread)
8d3788bd 1306 observer_notify_breakpoint_modified (b);
45a43567
TT
1307}
1308
1309/* Set the task for this breakpoint. If TASK is 0, make the
1310 breakpoint work for any task. */
1311
1312void
1313breakpoint_set_task (struct breakpoint *b, int task)
1314{
1315 int old_task = b->task;
1316
1317 b->task = task;
1318 if (old_task != task)
8d3788bd 1319 observer_notify_breakpoint_modified (b);
45a43567
TT
1320}
1321
95a42b64
TT
1322void
1323check_tracepoint_command (char *line, void *closure)
a7bdde9e 1324{
9a3c8263 1325 struct breakpoint *b = (struct breakpoint *) closure;
cc59ec59 1326
6f937416 1327 validate_actionline (line, b);
a7bdde9e
VP
1328}
1329
95a42b64
TT
1330/* A structure used to pass information through
1331 map_breakpoint_numbers. */
1332
1333struct commands_info
1334{
1335 /* True if the command was typed at a tty. */
1336 int from_tty;
86b17b60
PA
1337
1338 /* The breakpoint range spec. */
896b6bda 1339 const char *arg;
86b17b60 1340
95a42b64
TT
1341 /* Non-NULL if the body of the commands are being read from this
1342 already-parsed command. */
1343 struct command_line *control;
86b17b60 1344
95a42b64
TT
1345 /* The command lines read from the user, or NULL if they have not
1346 yet been read. */
1347 struct counted_command_line *cmd;
1348};
1349
1350/* A callback for map_breakpoint_numbers that sets the commands for
1351 commands_command. */
1352
c906108c 1353static void
95a42b64 1354do_map_commands_command (struct breakpoint *b, void *data)
c906108c 1355{
9a3c8263 1356 struct commands_info *info = (struct commands_info *) data;
c906108c 1357
95a42b64
TT
1358 if (info->cmd == NULL)
1359 {
93921405 1360 command_line_up l;
5c44784c 1361
95a42b64
TT
1362 if (info->control != NULL)
1363 l = copy_command_lines (info->control->body_list[0]);
1364 else
86b17b60
PA
1365 {
1366 struct cleanup *old_chain;
1367 char *str;
c5aa993b 1368
3e43a32a
MS
1369 str = xstrprintf (_("Type commands for breakpoint(s) "
1370 "%s, one per line."),
86b17b60
PA
1371 info->arg);
1372
1373 old_chain = make_cleanup (xfree, str);
1374
1375 l = read_command_lines (str,
1376 info->from_tty, 1,
d77f58be 1377 (is_tracepoint (b)
86b17b60
PA
1378 ? check_tracepoint_command : 0),
1379 b);
1380
1381 do_cleanups (old_chain);
1382 }
a7bdde9e 1383
93921405 1384 info->cmd = alloc_counted_command_line (l.release ());
95a42b64
TT
1385 }
1386
1387 /* If a breakpoint was on the list more than once, we don't need to
1388 do anything. */
1389 if (b->commands != info->cmd)
1390 {
1391 validate_commands_for_breakpoint (b, info->cmd->commands);
1392 incref_counted_command_line (info->cmd);
1393 decref_counted_command_line (&b->commands);
1394 b->commands = info->cmd;
8d3788bd 1395 observer_notify_breakpoint_modified (b);
c5aa993b 1396 }
95a42b64
TT
1397}
1398
1399static void
896b6bda 1400commands_command_1 (const char *arg, int from_tty,
4a64f543 1401 struct command_line *control)
95a42b64
TT
1402{
1403 struct cleanup *cleanups;
1404 struct commands_info info;
1405
1406 info.from_tty = from_tty;
1407 info.control = control;
1408 info.cmd = NULL;
1409 /* If we read command lines from the user, then `info' will hold an
1410 extra reference to the commands that we must clean up. */
1411 cleanups = make_cleanup_decref_counted_command_line (&info.cmd);
1412
896b6bda
PA
1413 std::string new_arg;
1414
95a42b64
TT
1415 if (arg == NULL || !*arg)
1416 {
86b17b60 1417 if (breakpoint_count - prev_breakpoint_count > 1)
896b6bda
PA
1418 new_arg = string_printf ("%d-%d", prev_breakpoint_count + 1,
1419 breakpoint_count);
95a42b64 1420 else if (breakpoint_count > 0)
896b6bda 1421 new_arg = string_printf ("%d", breakpoint_count);
95a42b64 1422 }
9766ced4 1423 else
896b6bda 1424 new_arg = arg;
86b17b60 1425
896b6bda 1426 info.arg = new_arg.c_str ();
95a42b64 1427
896b6bda 1428 map_breakpoint_numbers (info.arg, do_map_commands_command, &info);
95a42b64
TT
1429
1430 if (info.cmd == NULL)
1431 error (_("No breakpoints specified."));
1432
1433 do_cleanups (cleanups);
1434}
1435
1436static void
1437commands_command (char *arg, int from_tty)
1438{
1439 commands_command_1 (arg, from_tty, NULL);
c906108c 1440}
40c03ae8
EZ
1441
1442/* Like commands_command, but instead of reading the commands from
1443 input stream, takes them from an already parsed command structure.
1444
1445 This is used by cli-script.c to DTRT with breakpoint commands
1446 that are part of if and while bodies. */
1447enum command_control_type
896b6bda 1448commands_from_control_command (const char *arg, struct command_line *cmd)
40c03ae8 1449{
95a42b64
TT
1450 commands_command_1 (arg, 0, cmd);
1451 return simple_control;
40c03ae8 1452}
876fa593
JK
1453
1454/* Return non-zero if BL->TARGET_INFO contains valid information. */
1455
1456static int
1457bp_location_has_shadow (struct bp_location *bl)
1458{
1459 if (bl->loc_type != bp_loc_software_breakpoint)
1460 return 0;
1461 if (!bl->inserted)
1462 return 0;
1463 if (bl->target_info.shadow_len == 0)
e5dd4106 1464 /* BL isn't valid, or doesn't shadow memory. */
876fa593
JK
1465 return 0;
1466 return 1;
1467}
1468
9d497a19
PA
1469/* Update BUF, which is LEN bytes read from the target address
1470 MEMADDR, by replacing a memory breakpoint with its shadowed
1471 contents.
1472
1473 If READBUF is not NULL, this buffer must not overlap with the of
1474 the breakpoint location's shadow_contents buffer. Otherwise, a
1475 failed assertion internal error will be raised. */
1476
1477static void
1478one_breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1479 const gdb_byte *writebuf_org,
1480 ULONGEST memaddr, LONGEST len,
1481 struct bp_target_info *target_info,
1482 struct gdbarch *gdbarch)
1483{
1484 /* Now do full processing of the found relevant range of elements. */
1485 CORE_ADDR bp_addr = 0;
1486 int bp_size = 0;
1487 int bptoffset = 0;
1488
1489 if (!breakpoint_address_match (target_info->placed_address_space, 0,
1490 current_program_space->aspace, 0))
1491 {
1492 /* The breakpoint is inserted in a different address space. */
1493 return;
1494 }
1495
1496 /* Addresses and length of the part of the breakpoint that
1497 we need to copy. */
1498 bp_addr = target_info->placed_address;
1499 bp_size = target_info->shadow_len;
1500
1501 if (bp_addr + bp_size <= memaddr)
1502 {
1503 /* The breakpoint is entirely before the chunk of memory we are
1504 reading. */
1505 return;
1506 }
1507
1508 if (bp_addr >= memaddr + len)
1509 {
1510 /* The breakpoint is entirely after the chunk of memory we are
1511 reading. */
1512 return;
1513 }
1514
1515 /* Offset within shadow_contents. */
1516 if (bp_addr < memaddr)
1517 {
1518 /* Only copy the second part of the breakpoint. */
1519 bp_size -= memaddr - bp_addr;
1520 bptoffset = memaddr - bp_addr;
1521 bp_addr = memaddr;
1522 }
1523
1524 if (bp_addr + bp_size > memaddr + len)
1525 {
1526 /* Only copy the first part of the breakpoint. */
1527 bp_size -= (bp_addr + bp_size) - (memaddr + len);
1528 }
1529
1530 if (readbuf != NULL)
1531 {
1532 /* Verify that the readbuf buffer does not overlap with the
1533 shadow_contents buffer. */
1534 gdb_assert (target_info->shadow_contents >= readbuf + len
1535 || readbuf >= (target_info->shadow_contents
1536 + target_info->shadow_len));
1537
1538 /* Update the read buffer with this inserted breakpoint's
1539 shadow. */
1540 memcpy (readbuf + bp_addr - memaddr,
1541 target_info->shadow_contents + bptoffset, bp_size);
1542 }
1543 else
1544 {
1545 const unsigned char *bp;
0d5ed153
MR
1546 CORE_ADDR addr = target_info->reqstd_address;
1547 int placed_size;
9d497a19
PA
1548
1549 /* Update the shadow with what we want to write to memory. */
1550 memcpy (target_info->shadow_contents + bptoffset,
1551 writebuf_org + bp_addr - memaddr, bp_size);
1552
1553 /* Determine appropriate breakpoint contents and size for this
1554 address. */
0d5ed153 1555 bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &placed_size);
9d497a19
PA
1556
1557 /* Update the final write buffer with this inserted
1558 breakpoint's INSN. */
1559 memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1560 }
1561}
1562
8defab1a 1563/* Update BUF, which is LEN bytes read from the target address MEMADDR,
876fa593
JK
1564 by replacing any memory breakpoints with their shadowed contents.
1565
35c63cd8
JB
1566 If READBUF is not NULL, this buffer must not overlap with any of
1567 the breakpoint location's shadow_contents buffers. Otherwise,
1568 a failed assertion internal error will be raised.
1569
876fa593 1570 The range of shadowed area by each bp_location is:
f5336ca5
PA
1571 bl->address - bp_locations_placed_address_before_address_max
1572 up to bl->address + bp_locations_shadow_len_after_address_max
876fa593
JK
1573 The range we were requested to resolve shadows for is:
1574 memaddr ... memaddr + len
1575 Thus the safe cutoff boundaries for performance optimization are
35df4500 1576 memaddr + len <= (bl->address
f5336ca5 1577 - bp_locations_placed_address_before_address_max)
876fa593 1578 and:
f5336ca5 1579 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
c906108c 1580
8defab1a 1581void
f0ba3972
PA
1582breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1583 const gdb_byte *writebuf_org,
1584 ULONGEST memaddr, LONGEST len)
c906108c 1585{
4a64f543
MS
1586 /* Left boundary, right boundary and median element of our binary
1587 search. */
876fa593
JK
1588 unsigned bc_l, bc_r, bc;
1589
4a64f543
MS
1590 /* Find BC_L which is a leftmost element which may affect BUF
1591 content. It is safe to report lower value but a failure to
1592 report higher one. */
876fa593
JK
1593
1594 bc_l = 0;
f5336ca5 1595 bc_r = bp_locations_count;
876fa593
JK
1596 while (bc_l + 1 < bc_r)
1597 {
35df4500 1598 struct bp_location *bl;
876fa593
JK
1599
1600 bc = (bc_l + bc_r) / 2;
f5336ca5 1601 bl = bp_locations[bc];
876fa593 1602
4a64f543
MS
1603 /* Check first BL->ADDRESS will not overflow due to the added
1604 constant. Then advance the left boundary only if we are sure
1605 the BC element can in no way affect the BUF content (MEMADDR
1606 to MEMADDR + LEN range).
876fa593 1607
f5336ca5 1608 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
4a64f543
MS
1609 offset so that we cannot miss a breakpoint with its shadow
1610 range tail still reaching MEMADDR. */
c5aa993b 1611
f5336ca5 1612 if ((bl->address + bp_locations_shadow_len_after_address_max
35df4500 1613 >= bl->address)
f5336ca5 1614 && (bl->address + bp_locations_shadow_len_after_address_max
35df4500 1615 <= memaddr))
876fa593
JK
1616 bc_l = bc;
1617 else
1618 bc_r = bc;
1619 }
1620
128070bb
PA
1621 /* Due to the binary search above, we need to make sure we pick the
1622 first location that's at BC_L's address. E.g., if there are
1623 multiple locations at the same address, BC_L may end up pointing
1624 at a duplicate location, and miss the "master"/"inserted"
1625 location. Say, given locations L1, L2 and L3 at addresses A and
1626 B:
1627
1628 L1@A, L2@A, L3@B, ...
1629
1630 BC_L could end up pointing at location L2, while the "master"
1631 location could be L1. Since the `loc->inserted' flag is only set
1632 on "master" locations, we'd forget to restore the shadow of L1
1633 and L2. */
1634 while (bc_l > 0
f5336ca5 1635 && bp_locations[bc_l]->address == bp_locations[bc_l - 1]->address)
128070bb
PA
1636 bc_l--;
1637
876fa593
JK
1638 /* Now do full processing of the found relevant range of elements. */
1639
f5336ca5 1640 for (bc = bc_l; bc < bp_locations_count; bc++)
c5aa993b 1641 {
f5336ca5 1642 struct bp_location *bl = bp_locations[bc];
876fa593 1643
35df4500
TJB
1644 /* bp_location array has BL->OWNER always non-NULL. */
1645 if (bl->owner->type == bp_none)
8a3fe4f8 1646 warning (_("reading through apparently deleted breakpoint #%d?"),
35df4500 1647 bl->owner->number);
ffce0d52 1648
e5dd4106 1649 /* Performance optimization: any further element can no longer affect BUF
876fa593
JK
1650 content. */
1651
f5336ca5
PA
1652 if (bl->address >= bp_locations_placed_address_before_address_max
1653 && memaddr + len <= (bl->address
1654 - bp_locations_placed_address_before_address_max))
876fa593
JK
1655 break;
1656
35df4500 1657 if (!bp_location_has_shadow (bl))
c5aa993b 1658 continue;
6c95b8df 1659
9d497a19
PA
1660 one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
1661 memaddr, len, &bl->target_info, bl->gdbarch);
1662 }
c906108c 1663}
9d497a19 1664
c906108c 1665\f
c5aa993b 1666
b775012e
LM
1667/* Return true if BPT is either a software breakpoint or a hardware
1668 breakpoint. */
1669
1670int
1671is_breakpoint (const struct breakpoint *bpt)
1672{
1673 return (bpt->type == bp_breakpoint
e7e0cddf
SS
1674 || bpt->type == bp_hardware_breakpoint
1675 || bpt->type == bp_dprintf);
b775012e
LM
1676}
1677
60e1c644
PA
1678/* Return true if BPT is of any hardware watchpoint kind. */
1679
a5606eee 1680static int
d77f58be 1681is_hardware_watchpoint (const struct breakpoint *bpt)
a5606eee
VP
1682{
1683 return (bpt->type == bp_hardware_watchpoint
1684 || bpt->type == bp_read_watchpoint
1685 || bpt->type == bp_access_watchpoint);
1686}
7270d8f2 1687
60e1c644
PA
1688/* Return true if BPT is of any watchpoint kind, hardware or
1689 software. */
1690
3a5c3e22 1691int
d77f58be 1692is_watchpoint (const struct breakpoint *bpt)
60e1c644
PA
1693{
1694 return (is_hardware_watchpoint (bpt)
1695 || bpt->type == bp_watchpoint);
1696}
1697
3a5c3e22
PA
1698/* Returns true if the current thread and its running state are safe
1699 to evaluate or update watchpoint B. Watchpoints on local
1700 expressions need to be evaluated in the context of the thread that
1701 was current when the watchpoint was created, and, that thread needs
1702 to be stopped to be able to select the correct frame context.
1703 Watchpoints on global expressions can be evaluated on any thread,
1704 and in any state. It is presently left to the target allowing
1705 memory accesses when threads are running. */
f6bc2008
PA
1706
1707static int
3a5c3e22 1708watchpoint_in_thread_scope (struct watchpoint *b)
f6bc2008 1709{
d0d8b0c6
JK
1710 return (b->base.pspace == current_program_space
1711 && (ptid_equal (b->watchpoint_thread, null_ptid)
1712 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1713 && !is_executing (inferior_ptid))));
f6bc2008
PA
1714}
1715
d0fb5eae
JK
1716/* Set watchpoint B to disp_del_at_next_stop, even including its possible
1717 associated bp_watchpoint_scope breakpoint. */
1718
1719static void
3a5c3e22 1720watchpoint_del_at_next_stop (struct watchpoint *w)
d0fb5eae 1721{
3a5c3e22 1722 struct breakpoint *b = &w->base;
d0fb5eae
JK
1723
1724 if (b->related_breakpoint != b)
1725 {
1726 gdb_assert (b->related_breakpoint->type == bp_watchpoint_scope);
1727 gdb_assert (b->related_breakpoint->related_breakpoint == b);
1728 b->related_breakpoint->disposition = disp_del_at_next_stop;
1729 b->related_breakpoint->related_breakpoint = b->related_breakpoint;
1730 b->related_breakpoint = b;
1731 }
1732 b->disposition = disp_del_at_next_stop;
1733}
1734
bb9d5f81
PP
1735/* Extract a bitfield value from value VAL using the bit parameters contained in
1736 watchpoint W. */
1737
1738static struct value *
1739extract_bitfield_from_watchpoint_value (struct watchpoint *w, struct value *val)
1740{
1741 struct value *bit_val;
1742
1743 if (val == NULL)
1744 return NULL;
1745
1746 bit_val = allocate_value (value_type (val));
1747
1748 unpack_value_bitfield (bit_val,
1749 w->val_bitpos,
1750 w->val_bitsize,
1751 value_contents_for_printing (val),
1752 value_offset (val),
1753 val);
1754
1755 return bit_val;
1756}
1757
c6d81124
PA
1758/* Allocate a dummy location and add it to B, which must be a software
1759 watchpoint. This is required because even if a software watchpoint
1760 is not watching any memory, bpstat_stop_status requires a location
1761 to be able to report stops. */
1762
1763static void
1764software_watchpoint_add_no_memory_location (struct breakpoint *b,
1765 struct program_space *pspace)
1766{
1767 gdb_assert (b->type == bp_watchpoint && b->loc == NULL);
1768
1769 b->loc = allocate_bp_location (b);
1770 b->loc->pspace = pspace;
1771 b->loc->address = -1;
1772 b->loc->length = -1;
1773}
1774
1775/* Returns true if B is a software watchpoint that is not watching any
1776 memory (e.g., "watch $pc"). */
1777
1778static int
1779is_no_memory_software_watchpoint (struct breakpoint *b)
1780{
1781 return (b->type == bp_watchpoint
1782 && b->loc != NULL
1783 && b->loc->next == NULL
1784 && b->loc->address == -1
1785 && b->loc->length == -1);
1786}
1787
567e1b4e
JB
1788/* Assuming that B is a watchpoint:
1789 - Reparse watchpoint expression, if REPARSE is non-zero
a5606eee 1790 - Evaluate expression and store the result in B->val
567e1b4e
JB
1791 - Evaluate the condition if there is one, and store the result
1792 in b->loc->cond.
a5606eee
VP
1793 - Update the list of values that must be watched in B->loc.
1794
4a64f543
MS
1795 If the watchpoint disposition is disp_del_at_next_stop, then do
1796 nothing. If this is local watchpoint that is out of scope, delete
1797 it.
1798
1799 Even with `set breakpoint always-inserted on' the watchpoints are
1800 removed + inserted on each stop here. Normal breakpoints must
1801 never be removed because they might be missed by a running thread
1802 when debugging in non-stop mode. On the other hand, hardware
1803 watchpoints (is_hardware_watchpoint; processed here) are specific
1804 to each LWP since they are stored in each LWP's hardware debug
1805 registers. Therefore, such LWP must be stopped first in order to
1806 be able to modify its hardware watchpoints.
1807
1808 Hardware watchpoints must be reset exactly once after being
1809 presented to the user. It cannot be done sooner, because it would
1810 reset the data used to present the watchpoint hit to the user. And
1811 it must not be done later because it could display the same single
1812 watchpoint hit during multiple GDB stops. Note that the latter is
1813 relevant only to the hardware watchpoint types bp_read_watchpoint
1814 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1815 not user-visible - its hit is suppressed if the memory content has
1816 not changed.
1817
1818 The following constraints influence the location where we can reset
1819 hardware watchpoints:
1820
1821 * target_stopped_by_watchpoint and target_stopped_data_address are
1822 called several times when GDB stops.
1823
1824 [linux]
1825 * Multiple hardware watchpoints can be hit at the same time,
1826 causing GDB to stop. GDB only presents one hardware watchpoint
1827 hit at a time as the reason for stopping, and all the other hits
1828 are presented later, one after the other, each time the user
1829 requests the execution to be resumed. Execution is not resumed
1830 for the threads still having pending hit event stored in
1831 LWP_INFO->STATUS. While the watchpoint is already removed from
1832 the inferior on the first stop the thread hit event is kept being
1833 reported from its cached value by linux_nat_stopped_data_address
1834 until the real thread resume happens after the watchpoint gets
1835 presented and thus its LWP_INFO->STATUS gets reset.
1836
1837 Therefore the hardware watchpoint hit can get safely reset on the
1838 watchpoint removal from inferior. */
a79d3c27 1839
b40ce68a 1840static void
3a5c3e22 1841update_watchpoint (struct watchpoint *b, int reparse)
7270d8f2 1842{
a5606eee 1843 int within_current_scope;
a5606eee 1844 struct frame_id saved_frame_id;
66076460 1845 int frame_saved;
a5606eee 1846
f6bc2008
PA
1847 /* If this is a local watchpoint, we only want to check if the
1848 watchpoint frame is in scope if the current thread is the thread
1849 that was used to create the watchpoint. */
1850 if (!watchpoint_in_thread_scope (b))
1851 return;
1852
3a5c3e22 1853 if (b->base.disposition == disp_del_at_next_stop)
a5606eee
VP
1854 return;
1855
66076460 1856 frame_saved = 0;
a5606eee
VP
1857
1858 /* Determine if the watchpoint is within scope. */
1859 if (b->exp_valid_block == NULL)
1860 within_current_scope = 1;
1861 else
1862 {
b5db5dfc
UW
1863 struct frame_info *fi = get_current_frame ();
1864 struct gdbarch *frame_arch = get_frame_arch (fi);
1865 CORE_ADDR frame_pc = get_frame_pc (fi);
1866
c9cf6e20
MG
1867 /* If we're at a point where the stack has been destroyed
1868 (e.g. in a function epilogue), unwinding may not work
1869 properly. Do not attempt to recreate locations at this
b5db5dfc 1870 point. See similar comments in watchpoint_check. */
c9cf6e20 1871 if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
b5db5dfc 1872 return;
66076460
DJ
1873
1874 /* Save the current frame's ID so we can restore it after
1875 evaluating the watchpoint expression on its own frame. */
1876 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1877 took a frame parameter, so that we didn't have to change the
1878 selected frame. */
1879 frame_saved = 1;
1880 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1881
a5606eee
VP
1882 fi = frame_find_by_id (b->watchpoint_frame);
1883 within_current_scope = (fi != NULL);
1884 if (within_current_scope)
1885 select_frame (fi);
1886 }
1887
b5db5dfc
UW
1888 /* We don't free locations. They are stored in the bp_location array
1889 and update_global_location_list will eventually delete them and
1890 remove breakpoints if needed. */
3a5c3e22 1891 b->base.loc = NULL;
b5db5dfc 1892
a5606eee
VP
1893 if (within_current_scope && reparse)
1894 {
bbc13ae3 1895 const char *s;
d63d0675 1896
4d01a485 1897 b->exp.reset ();
d63d0675 1898 s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1bb9788d 1899 b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
a5606eee
VP
1900 /* If the meaning of expression itself changed, the old value is
1901 no longer relevant. We don't want to report a watchpoint hit
1902 to the user when the old value and the new value may actually
1903 be completely different objects. */
1904 value_free (b->val);
fa4727a6
DJ
1905 b->val = NULL;
1906 b->val_valid = 0;
60e1c644
PA
1907
1908 /* Note that unlike with breakpoints, the watchpoint's condition
1909 expression is stored in the breakpoint object, not in the
1910 locations (re)created below. */
3a5c3e22 1911 if (b->base.cond_string != NULL)
60e1c644 1912 {
4d01a485 1913 b->cond_exp.reset ();
60e1c644 1914
3a5c3e22 1915 s = b->base.cond_string;
1bb9788d 1916 b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
60e1c644 1917 }
a5606eee 1918 }
a5606eee
VP
1919
1920 /* If we failed to parse the expression, for example because
1921 it refers to a global variable in a not-yet-loaded shared library,
1922 don't try to insert watchpoint. We don't automatically delete
1923 such watchpoint, though, since failure to parse expression
1924 is different from out-of-scope watchpoint. */
e8369a73 1925 if (!target_has_execution)
2d134ed3
PA
1926 {
1927 /* Without execution, memory can't change. No use to try and
1928 set watchpoint locations. The watchpoint will be reset when
1929 the target gains execution, through breakpoint_re_set. */
e8369a73
AB
1930 if (!can_use_hw_watchpoints)
1931 {
1932 if (b->base.ops->works_in_software_mode (&b->base))
1933 b->base.type = bp_watchpoint;
1934 else
638aa5a1
AB
1935 error (_("Can't set read/access watchpoint when "
1936 "hardware watchpoints are disabled."));
e8369a73 1937 }
2d134ed3
PA
1938 }
1939 else if (within_current_scope && b->exp)
a5606eee 1940 {
0cf6dd15 1941 int pc = 0;
fa4727a6 1942 struct value *val_chain, *v, *result, *next;
2d134ed3 1943 struct program_space *frame_pspace;
a5606eee 1944
4d01a485 1945 fetch_subexp_value (b->exp.get (), &pc, &v, &result, &val_chain, 0);
a5606eee 1946
a5606eee
VP
1947 /* Avoid setting b->val if it's already set. The meaning of
1948 b->val is 'the last value' user saw, and we should update
1949 it only if we reported that last value to user. As it
9c06b0b4
TJB
1950 happens, the code that reports it updates b->val directly.
1951 We don't keep track of the memory value for masked
1952 watchpoints. */
3a5c3e22 1953 if (!b->val_valid && !is_masked_watchpoint (&b->base))
fa4727a6 1954 {
bb9d5f81
PP
1955 if (b->val_bitsize != 0)
1956 {
1957 v = extract_bitfield_from_watchpoint_value (b, v);
1958 if (v != NULL)
1959 release_value (v);
1960 }
fa4727a6
DJ
1961 b->val = v;
1962 b->val_valid = 1;
1963 }
a5606eee 1964
2d134ed3
PA
1965 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1966
a5606eee 1967 /* Look at each value on the value chain. */
9fa40276 1968 for (v = val_chain; v; v = value_next (v))
a5606eee
VP
1969 {
1970 /* If it's a memory location, and GDB actually needed
1971 its contents to evaluate the expression, then we
fa4727a6
DJ
1972 must watch it. If the first value returned is
1973 still lazy, that means an error occurred reading it;
1974 watch it anyway in case it becomes readable. */
a5606eee 1975 if (VALUE_LVAL (v) == lval_memory
fa4727a6 1976 && (v == val_chain || ! value_lazy (v)))
a5606eee
VP
1977 {
1978 struct type *vtype = check_typedef (value_type (v));
7270d8f2 1979
a5606eee
VP
1980 /* We only watch structs and arrays if user asked
1981 for it explicitly, never if they just happen to
1982 appear in the middle of some value chain. */
fa4727a6 1983 if (v == result
a5606eee
VP
1984 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1985 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1986 {
1987 CORE_ADDR addr;
f486487f 1988 enum target_hw_bp_type type;
a5606eee 1989 struct bp_location *loc, **tmp;
bb9d5f81
PP
1990 int bitpos = 0, bitsize = 0;
1991
1992 if (value_bitsize (v) != 0)
1993 {
1994 /* Extract the bit parameters out from the bitfield
1995 sub-expression. */
1996 bitpos = value_bitpos (v);
1997 bitsize = value_bitsize (v);
1998 }
1999 else if (v == result && b->val_bitsize != 0)
2000 {
2001 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
2002 lvalue whose bit parameters are saved in the fields
2003 VAL_BITPOS and VAL_BITSIZE. */
2004 bitpos = b->val_bitpos;
2005 bitsize = b->val_bitsize;
2006 }
a5606eee 2007
42ae5230 2008 addr = value_address (v);
bb9d5f81
PP
2009 if (bitsize != 0)
2010 {
2011 /* Skip the bytes that don't contain the bitfield. */
2012 addr += bitpos / 8;
2013 }
2014
a5606eee 2015 type = hw_write;
3a5c3e22 2016 if (b->base.type == bp_read_watchpoint)
a5606eee 2017 type = hw_read;
3a5c3e22 2018 else if (b->base.type == bp_access_watchpoint)
a5606eee 2019 type = hw_access;
3a5c3e22
PA
2020
2021 loc = allocate_bp_location (&b->base);
2022 for (tmp = &(b->base.loc); *tmp != NULL; tmp = &((*tmp)->next))
a5606eee
VP
2023 ;
2024 *tmp = loc;
a6d9a66e 2025 loc->gdbarch = get_type_arch (value_type (v));
6c95b8df
PA
2026
2027 loc->pspace = frame_pspace;
a5606eee 2028 loc->address = addr;
bb9d5f81
PP
2029
2030 if (bitsize != 0)
2031 {
2032 /* Just cover the bytes that make up the bitfield. */
2033 loc->length = ((bitpos % 8) + bitsize + 7) / 8;
2034 }
2035 else
2036 loc->length = TYPE_LENGTH (value_type (v));
2037
a5606eee
VP
2038 loc->watchpoint_type = type;
2039 }
2040 }
9fa40276
TJB
2041 }
2042
2043 /* Change the type of breakpoint between hardware assisted or
2044 an ordinary watchpoint depending on the hardware support
2045 and free hardware slots. REPARSE is set when the inferior
2046 is started. */
a9634178 2047 if (reparse)
9fa40276 2048 {
e09342b5 2049 int reg_cnt;
9fa40276
TJB
2050 enum bp_loc_type loc_type;
2051 struct bp_location *bl;
a5606eee 2052
a9634178 2053 reg_cnt = can_use_hardware_watchpoint (val_chain);
e09342b5
TJB
2054
2055 if (reg_cnt)
9fa40276
TJB
2056 {
2057 int i, target_resources_ok, other_type_used;
a1398e0c 2058 enum bptype type;
9fa40276 2059
a9634178
TJB
2060 /* Use an exact watchpoint when there's only one memory region to be
2061 watched, and only one debug register is needed to watch it. */
2062 b->exact = target_exact_watchpoints && reg_cnt == 1;
2063
9fa40276 2064 /* We need to determine how many resources are already
e09342b5
TJB
2065 used for all other hardware watchpoints plus this one
2066 to see if we still have enough resources to also fit
a1398e0c
PA
2067 this watchpoint in as well. */
2068
2069 /* If this is a software watchpoint, we try to turn it
2070 to a hardware one -- count resources as if B was of
2071 hardware watchpoint type. */
2072 type = b->base.type;
2073 if (type == bp_watchpoint)
2074 type = bp_hardware_watchpoint;
2075
2076 /* This watchpoint may or may not have been placed on
2077 the list yet at this point (it won't be in the list
2078 if we're trying to create it for the first time,
2079 through watch_command), so always account for it
2080 manually. */
2081
2082 /* Count resources used by all watchpoints except B. */
2083 i = hw_watchpoint_used_count_others (&b->base, type, &other_type_used);
2084
2085 /* Add in the resources needed for B. */
2086 i += hw_watchpoint_use_count (&b->base);
2087
2088 target_resources_ok
2089 = target_can_use_hardware_watchpoint (type, i, other_type_used);
e09342b5 2090 if (target_resources_ok <= 0)
a9634178 2091 {
3a5c3e22 2092 int sw_mode = b->base.ops->works_in_software_mode (&b->base);
9c06b0b4
TJB
2093
2094 if (target_resources_ok == 0 && !sw_mode)
a9634178
TJB
2095 error (_("Target does not support this type of "
2096 "hardware watchpoint."));
9c06b0b4
TJB
2097 else if (target_resources_ok < 0 && !sw_mode)
2098 error (_("There are not enough available hardware "
2099 "resources for this watchpoint."));
a1398e0c
PA
2100
2101 /* Downgrade to software watchpoint. */
2102 b->base.type = bp_watchpoint;
2103 }
2104 else
2105 {
2106 /* If this was a software watchpoint, we've just
2107 found we have enough resources to turn it to a
2108 hardware watchpoint. Otherwise, this is a
2109 nop. */
2110 b->base.type = type;
a9634178 2111 }
9fa40276 2112 }
3a5c3e22 2113 else if (!b->base.ops->works_in_software_mode (&b->base))
638aa5a1
AB
2114 {
2115 if (!can_use_hw_watchpoints)
2116 error (_("Can't set read/access watchpoint when "
2117 "hardware watchpoints are disabled."));
2118 else
2119 error (_("Expression cannot be implemented with "
2120 "read/access watchpoint."));
2121 }
9fa40276 2122 else
3a5c3e22 2123 b->base.type = bp_watchpoint;
9fa40276 2124
3a5c3e22 2125 loc_type = (b->base.type == bp_watchpoint? bp_loc_other
9fa40276 2126 : bp_loc_hardware_watchpoint);
3a5c3e22 2127 for (bl = b->base.loc; bl; bl = bl->next)
9fa40276
TJB
2128 bl->loc_type = loc_type;
2129 }
2130
2131 for (v = val_chain; v; v = next)
2132 {
a5606eee
VP
2133 next = value_next (v);
2134 if (v != b->val)
2135 value_free (v);
2136 }
2137
c7437ca6
PA
2138 /* If a software watchpoint is not watching any memory, then the
2139 above left it without any location set up. But,
2140 bpstat_stop_status requires a location to be able to report
2141 stops, so make sure there's at least a dummy one. */
3a5c3e22 2142 if (b->base.type == bp_watchpoint && b->base.loc == NULL)
c6d81124 2143 software_watchpoint_add_no_memory_location (&b->base, frame_pspace);
a5606eee
VP
2144 }
2145 else if (!within_current_scope)
7270d8f2 2146 {
ac74f770
MS
2147 printf_filtered (_("\
2148Watchpoint %d deleted because the program has left the block\n\
2149in which its expression is valid.\n"),
3a5c3e22 2150 b->base.number);
d0fb5eae 2151 watchpoint_del_at_next_stop (b);
7270d8f2 2152 }
a5606eee
VP
2153
2154 /* Restore the selected frame. */
66076460
DJ
2155 if (frame_saved)
2156 select_frame (frame_find_by_id (saved_frame_id));
7270d8f2
OF
2157}
2158
a5606eee 2159
74960c60 2160/* Returns 1 iff breakpoint location should be
1e4d1764
YQ
2161 inserted in the inferior. We don't differentiate the type of BL's owner
2162 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2163 breakpoint_ops is not defined, because in insert_bp_location,
2164 tracepoint's insert_location will not be called. */
74960c60 2165static int
35df4500 2166should_be_inserted (struct bp_location *bl)
74960c60 2167{
35df4500 2168 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
74960c60
VP
2169 return 0;
2170
35df4500 2171 if (bl->owner->disposition == disp_del_at_next_stop)
74960c60
VP
2172 return 0;
2173
35df4500 2174 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
74960c60
VP
2175 return 0;
2176
f8eba3c6
TT
2177 if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2178 return 0;
2179
56710373
PA
2180 /* This is set for example, when we're attached to the parent of a
2181 vfork, and have detached from the child. The child is running
2182 free, and we expect it to do an exec or exit, at which point the
2183 OS makes the parent schedulable again (and the target reports
2184 that the vfork is done). Until the child is done with the shared
2185 memory region, do not insert breakpoints in the parent, otherwise
2186 the child could still trip on the parent's breakpoints. Since
2187 the parent is blocked anyway, it won't miss any breakpoint. */
35df4500 2188 if (bl->pspace->breakpoints_not_allowed)
56710373
PA
2189 return 0;
2190
31e77af2 2191 /* Don't insert a breakpoint if we're trying to step past its
21edc42f
YQ
2192 location, except if the breakpoint is a single-step breakpoint,
2193 and the breakpoint's thread is the thread which is stepping past
2194 a breakpoint. */
31e77af2
PA
2195 if ((bl->loc_type == bp_loc_software_breakpoint
2196 || bl->loc_type == bp_loc_hardware_breakpoint)
2197 && stepping_past_instruction_at (bl->pspace->aspace,
21edc42f
YQ
2198 bl->address)
2199 /* The single-step breakpoint may be inserted at the location
2200 we're trying to step if the instruction branches to itself.
2201 However, the instruction won't be executed at all and it may
2202 break the semantics of the instruction, for example, the
2203 instruction is a conditional branch or updates some flags.
2204 We can't fix it unless GDB is able to emulate the instruction
2205 or switch to displaced stepping. */
2206 && !(bl->owner->type == bp_single_step
2207 && thread_is_stepping_over_breakpoint (bl->owner->thread)))
e558d7c1
PA
2208 {
2209 if (debug_infrun)
2210 {
2211 fprintf_unfiltered (gdb_stdlog,
2212 "infrun: skipping breakpoint: "
2213 "stepping past insn at: %s\n",
2214 paddress (bl->gdbarch, bl->address));
2215 }
2216 return 0;
2217 }
31e77af2 2218
963f9c80
PA
2219 /* Don't insert watchpoints if we're trying to step past the
2220 instruction that triggered one. */
2221 if ((bl->loc_type == bp_loc_hardware_watchpoint)
2222 && stepping_past_nonsteppable_watchpoint ())
2223 {
2224 if (debug_infrun)
2225 {
2226 fprintf_unfiltered (gdb_stdlog,
2227 "infrun: stepping past non-steppable watchpoint. "
2228 "skipping watchpoint at %s:%d\n",
2229 paddress (bl->gdbarch, bl->address),
2230 bl->length);
2231 }
2232 return 0;
2233 }
2234
74960c60
VP
2235 return 1;
2236}
2237
934709f0
PW
2238/* Same as should_be_inserted but does the check assuming
2239 that the location is not duplicated. */
2240
2241static int
2242unduplicated_should_be_inserted (struct bp_location *bl)
2243{
2244 int result;
2245 const int save_duplicate = bl->duplicate;
2246
2247 bl->duplicate = 0;
2248 result = should_be_inserted (bl);
2249 bl->duplicate = save_duplicate;
2250 return result;
2251}
2252
b775012e
LM
2253/* Parses a conditional described by an expression COND into an
2254 agent expression bytecode suitable for evaluation
2255 by the bytecode interpreter. Return NULL if there was
2256 any error during parsing. */
2257
833177a4 2258static agent_expr_up
b775012e
LM
2259parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2260{
833177a4 2261 if (cond == NULL)
b775012e
LM
2262 return NULL;
2263
833177a4
PA
2264 agent_expr_up aexpr;
2265
b775012e
LM
2266 /* We don't want to stop processing, so catch any errors
2267 that may show up. */
492d29ea 2268 TRY
b775012e 2269 {
036e657b 2270 aexpr = gen_eval_for_expr (scope, cond);
b775012e
LM
2271 }
2272
492d29ea 2273 CATCH (ex, RETURN_MASK_ERROR)
b775012e
LM
2274 {
2275 /* If we got here, it means the condition could not be parsed to a valid
2276 bytecode expression and thus can't be evaluated on the target's side.
2277 It's no use iterating through the conditions. */
b775012e 2278 }
492d29ea 2279 END_CATCH
b775012e
LM
2280
2281 /* We have a valid agent expression. */
2282 return aexpr;
2283}
2284
2285/* Based on location BL, create a list of breakpoint conditions to be
2286 passed on to the target. If we have duplicated locations with different
2287 conditions, we will add such conditions to the list. The idea is that the
2288 target will evaluate the list of conditions and will only notify GDB when
2289 one of them is true. */
2290
2291static void
2292build_target_condition_list (struct bp_location *bl)
2293{
2294 struct bp_location **locp = NULL, **loc2p;
2295 int null_condition_or_parse_error = 0;
2296 int modified = bl->needs_update;
2297 struct bp_location *loc;
2298
8b4f3082 2299 /* Release conditions left over from a previous insert. */
3cde5c42 2300 bl->target_info.conditions.clear ();
8b4f3082 2301
b775012e
LM
2302 /* This is only meaningful if the target is
2303 evaluating conditions and if the user has
2304 opted for condition evaluation on the target's
2305 side. */
2306 if (gdb_evaluates_breakpoint_condition_p ()
2307 || !target_supports_evaluation_of_breakpoint_conditions ())
2308 return;
2309
2310 /* Do a first pass to check for locations with no assigned
2311 conditions or conditions that fail to parse to a valid agent expression
2312 bytecode. If any of these happen, then it's no use to send conditions
2313 to the target since this location will always trigger and generate a
2314 response back to GDB. */
2315 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2316 {
2317 loc = (*loc2p);
2318 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2319 {
2320 if (modified)
2321 {
b775012e
LM
2322 /* Re-parse the conditions since something changed. In that
2323 case we already freed the condition bytecodes (see
2324 force_breakpoint_reinsertion). We just
2325 need to parse the condition to bytecodes again. */
833177a4
PA
2326 loc->cond_bytecode = parse_cond_to_aexpr (bl->address,
2327 loc->cond.get ());
b775012e
LM
2328 }
2329
2330 /* If we have a NULL bytecode expression, it means something
2331 went wrong or we have a null condition expression. */
2332 if (!loc->cond_bytecode)
2333 {
2334 null_condition_or_parse_error = 1;
2335 break;
2336 }
2337 }
2338 }
2339
2340 /* If any of these happened, it means we will have to evaluate the conditions
2341 for the location's address on gdb's side. It is no use keeping bytecodes
2342 for all the other duplicate locations, thus we free all of them here.
2343
2344 This is so we have a finer control over which locations' conditions are
2345 being evaluated by GDB or the remote stub. */
2346 if (null_condition_or_parse_error)
2347 {
2348 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2349 {
2350 loc = (*loc2p);
2351 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2352 {
2353 /* Only go as far as the first NULL bytecode is
2354 located. */
2355 if (!loc->cond_bytecode)
2356 return;
2357
833177a4 2358 loc->cond_bytecode.reset ();
b775012e
LM
2359 }
2360 }
2361 }
2362
2363 /* No NULL conditions or failed bytecode generation. Build a condition list
2364 for this location's address. */
2365 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2366 {
2367 loc = (*loc2p);
2368 if (loc->cond
2369 && is_breakpoint (loc->owner)
2370 && loc->pspace->num == bl->pspace->num
2371 && loc->owner->enable_state == bp_enabled
2372 && loc->enabled)
3cde5c42
PA
2373 {
2374 /* Add the condition to the vector. This will be used later
2375 to send the conditions to the target. */
2376 bl->target_info.conditions.push_back (loc->cond_bytecode.get ());
2377 }
b775012e
LM
2378 }
2379
2380 return;
2381}
2382
d3ce09f5
SS
2383/* Parses a command described by string CMD into an agent expression
2384 bytecode suitable for evaluation by the bytecode interpreter.
2385 Return NULL if there was any error during parsing. */
2386
833177a4 2387static agent_expr_up
d3ce09f5
SS
2388parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2389{
2390 struct cleanup *old_cleanups = 0;
4d01a485 2391 struct expression **argvec;
bbc13ae3
KS
2392 const char *cmdrest;
2393 const char *format_start, *format_end;
d3ce09f5
SS
2394 struct format_piece *fpieces;
2395 int nargs;
2396 struct gdbarch *gdbarch = get_current_arch ();
2397
833177a4 2398 if (cmd == NULL)
d3ce09f5
SS
2399 return NULL;
2400
2401 cmdrest = cmd;
2402
2403 if (*cmdrest == ',')
2404 ++cmdrest;
bbc13ae3 2405 cmdrest = skip_spaces_const (cmdrest);
d3ce09f5
SS
2406
2407 if (*cmdrest++ != '"')
2408 error (_("No format string following the location"));
2409
2410 format_start = cmdrest;
2411
2412 fpieces = parse_format_string (&cmdrest);
2413
2414 old_cleanups = make_cleanup (free_format_pieces_cleanup, &fpieces);
2415
2416 format_end = cmdrest;
2417
2418 if (*cmdrest++ != '"')
2419 error (_("Bad format string, non-terminated '\"'."));
2420
bbc13ae3 2421 cmdrest = skip_spaces_const (cmdrest);
d3ce09f5
SS
2422
2423 if (!(*cmdrest == ',' || *cmdrest == '\0'))
2424 error (_("Invalid argument syntax"));
2425
2426 if (*cmdrest == ',')
2427 cmdrest++;
bbc13ae3 2428 cmdrest = skip_spaces_const (cmdrest);
d3ce09f5
SS
2429
2430 /* For each argument, make an expression. */
2431
2432 argvec = (struct expression **) alloca (strlen (cmd)
2433 * sizeof (struct expression *));
2434
2435 nargs = 0;
2436 while (*cmdrest != '\0')
2437 {
bbc13ae3 2438 const char *cmd1;
d3ce09f5
SS
2439
2440 cmd1 = cmdrest;
4d01a485
PA
2441 expression_up expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2442 argvec[nargs++] = expr.release ();
d3ce09f5
SS
2443 cmdrest = cmd1;
2444 if (*cmdrest == ',')
2445 ++cmdrest;
2446 }
2447
833177a4
PA
2448 agent_expr_up aexpr;
2449
d3ce09f5
SS
2450 /* We don't want to stop processing, so catch any errors
2451 that may show up. */
492d29ea 2452 TRY
d3ce09f5 2453 {
036e657b
JB
2454 aexpr = gen_printf (scope, gdbarch, 0, 0,
2455 format_start, format_end - format_start,
2456 fpieces, nargs, argvec);
d3ce09f5 2457 }
492d29ea 2458 CATCH (ex, RETURN_MASK_ERROR)
d3ce09f5
SS
2459 {
2460 /* If we got here, it means the command could not be parsed to a valid
2461 bytecode expression and thus can't be evaluated on the target's side.
2462 It's no use iterating through the other commands. */
d3ce09f5 2463 }
492d29ea
PA
2464 END_CATCH
2465
2466 do_cleanups (old_cleanups);
d3ce09f5 2467
d3ce09f5
SS
2468 /* We have a valid agent expression, return it. */
2469 return aexpr;
2470}
2471
2472/* Based on location BL, create a list of breakpoint commands to be
2473 passed on to the target. If we have duplicated locations with
2474 different commands, we will add any such to the list. */
2475
2476static void
2477build_target_command_list (struct bp_location *bl)
2478{
2479 struct bp_location **locp = NULL, **loc2p;
2480 int null_command_or_parse_error = 0;
2481 int modified = bl->needs_update;
2482 struct bp_location *loc;
2483
3cde5c42
PA
2484 /* Clear commands left over from a previous insert. */
2485 bl->target_info.tcommands.clear ();
8b4f3082 2486
41fac0cf 2487 if (!target_can_run_breakpoint_commands ())
d3ce09f5
SS
2488 return;
2489
41fac0cf
PA
2490 /* For now, limit to agent-style dprintf breakpoints. */
2491 if (dprintf_style != dprintf_style_agent)
d3ce09f5
SS
2492 return;
2493
41fac0cf
PA
2494 /* For now, if we have any duplicate location that isn't a dprintf,
2495 don't install the target-side commands, as that would make the
2496 breakpoint not be reported to the core, and we'd lose
2497 control. */
2498 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2499 {
2500 loc = (*loc2p);
2501 if (is_breakpoint (loc->owner)
2502 && loc->pspace->num == bl->pspace->num
2503 && loc->owner->type != bp_dprintf)
2504 return;
2505 }
2506
d3ce09f5
SS
2507 /* Do a first pass to check for locations with no assigned
2508 conditions or conditions that fail to parse to a valid agent expression
2509 bytecode. If any of these happen, then it's no use to send conditions
2510 to the target since this location will always trigger and generate a
2511 response back to GDB. */
2512 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2513 {
2514 loc = (*loc2p);
2515 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2516 {
2517 if (modified)
2518 {
d3ce09f5
SS
2519 /* Re-parse the commands since something changed. In that
2520 case we already freed the command bytecodes (see
2521 force_breakpoint_reinsertion). We just
2522 need to parse the command to bytecodes again. */
833177a4
PA
2523 loc->cmd_bytecode
2524 = parse_cmd_to_aexpr (bl->address,
2525 loc->owner->extra_string);
d3ce09f5
SS
2526 }
2527
2528 /* If we have a NULL bytecode expression, it means something
2529 went wrong or we have a null command expression. */
2530 if (!loc->cmd_bytecode)
2531 {
2532 null_command_or_parse_error = 1;
2533 break;
2534 }
2535 }
2536 }
2537
2538 /* If anything failed, then we're not doing target-side commands,
2539 and so clean up. */
2540 if (null_command_or_parse_error)
2541 {
2542 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2543 {
2544 loc = (*loc2p);
2545 if (is_breakpoint (loc->owner)
2546 && loc->pspace->num == bl->pspace->num)
2547 {
2548 /* Only go as far as the first NULL bytecode is
2549 located. */
40fb6c5e 2550 if (loc->cmd_bytecode == NULL)
d3ce09f5
SS
2551 return;
2552
833177a4 2553 loc->cmd_bytecode.reset ();
d3ce09f5
SS
2554 }
2555 }
2556 }
2557
2558 /* No NULL commands or failed bytecode generation. Build a command list
2559 for this location's address. */
2560 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2561 {
2562 loc = (*loc2p);
2563 if (loc->owner->extra_string
2564 && is_breakpoint (loc->owner)
2565 && loc->pspace->num == bl->pspace->num
2566 && loc->owner->enable_state == bp_enabled
2567 && loc->enabled)
3cde5c42
PA
2568 {
2569 /* Add the command to the vector. This will be used later
2570 to send the commands to the target. */
2571 bl->target_info.tcommands.push_back (loc->cmd_bytecode.get ());
2572 }
d3ce09f5
SS
2573 }
2574
2575 bl->target_info.persist = 0;
2576 /* Maybe flag this location as persistent. */
2577 if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2578 bl->target_info.persist = 1;
2579}
2580
833b7ab5
YQ
2581/* Return the kind of breakpoint on address *ADDR. Get the kind
2582 of breakpoint according to ADDR except single-step breakpoint.
2583 Get the kind of single-step breakpoint according to the current
2584 registers state. */
cd6c3b4f
YQ
2585
2586static int
2587breakpoint_kind (struct bp_location *bl, CORE_ADDR *addr)
2588{
833b7ab5
YQ
2589 if (bl->owner->type == bp_single_step)
2590 {
2591 struct thread_info *thr = find_thread_global_id (bl->owner->thread);
2592 struct regcache *regcache;
2593
2594 regcache = get_thread_regcache (thr->ptid);
2595
2596 return gdbarch_breakpoint_kind_from_current_state (bl->gdbarch,
2597 regcache, addr);
2598 }
2599 else
2600 return gdbarch_breakpoint_kind_from_pc (bl->gdbarch, addr);
cd6c3b4f
YQ
2601}
2602
35df4500
TJB
2603/* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2604 location. Any error messages are printed to TMP_ERROR_STREAM; and
3fbb6ffa 2605 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
c30eee59
TJB
2606 Returns 0 for success, 1 if the bp_location type is not supported or
2607 -1 for failure.
879bfdc2 2608
4a64f543
MS
2609 NOTE drow/2003-09-09: This routine could be broken down to an
2610 object-style method for each breakpoint or catchpoint type. */
26bb91f3 2611static int
35df4500 2612insert_bp_location (struct bp_location *bl,
26bb91f3 2613 struct ui_file *tmp_error_stream,
3fbb6ffa 2614 int *disabled_breaks,
dd61ec5c
MW
2615 int *hw_breakpoint_error,
2616 int *hw_bp_error_explained_already)
879bfdc2 2617{
0000e5cc
PA
2618 enum errors bp_err = GDB_NO_ERROR;
2619 const char *bp_err_message = NULL;
879bfdc2 2620
b775012e 2621 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
879bfdc2
DJ
2622 return 0;
2623
35c63cd8
JB
2624 /* Note we don't initialize bl->target_info, as that wipes out
2625 the breakpoint location's shadow_contents if the breakpoint
2626 is still inserted at that location. This in turn breaks
2627 target_read_memory which depends on these buffers when
2628 a memory read is requested at the breakpoint location:
2629 Once the target_info has been wiped, we fail to see that
2630 we have a breakpoint inserted at that address and thus
2631 read the breakpoint instead of returning the data saved in
2632 the breakpoint location's shadow contents. */
0d5ed153 2633 bl->target_info.reqstd_address = bl->address;
35df4500 2634 bl->target_info.placed_address_space = bl->pspace->aspace;
f1310107 2635 bl->target_info.length = bl->length;
8181d85f 2636
b775012e
LM
2637 /* When working with target-side conditions, we must pass all the conditions
2638 for the same breakpoint address down to the target since GDB will not
2639 insert those locations. With a list of breakpoint conditions, the target
2640 can decide when to stop and notify GDB. */
2641
2642 if (is_breakpoint (bl->owner))
2643 {
2644 build_target_condition_list (bl);
d3ce09f5
SS
2645 build_target_command_list (bl);
2646 /* Reset the modification marker. */
b775012e
LM
2647 bl->needs_update = 0;
2648 }
2649
35df4500
TJB
2650 if (bl->loc_type == bp_loc_software_breakpoint
2651 || bl->loc_type == bp_loc_hardware_breakpoint)
879bfdc2 2652 {
35df4500 2653 if (bl->owner->type != bp_hardware_breakpoint)
765dc015
VP
2654 {
2655 /* If the explicitly specified breakpoint type
2656 is not hardware breakpoint, check the memory map to see
2657 if the breakpoint address is in read only memory or not.
4a64f543 2658
765dc015
VP
2659 Two important cases are:
2660 - location type is not hardware breakpoint, memory
2661 is readonly. We change the type of the location to
2662 hardware breakpoint.
4a64f543
MS
2663 - location type is hardware breakpoint, memory is
2664 read-write. This means we've previously made the
2665 location hardware one, but then the memory map changed,
2666 so we undo.
765dc015 2667
4a64f543
MS
2668 When breakpoints are removed, remove_breakpoints will use
2669 location types we've just set here, the only possible
2670 problem is that memory map has changed during running
2671 program, but it's not going to work anyway with current
2672 gdb. */
765dc015 2673 struct mem_region *mr
0d5ed153 2674 = lookup_mem_region (bl->target_info.reqstd_address);
765dc015
VP
2675
2676 if (mr)
2677 {
2678 if (automatic_hardware_breakpoints)
2679 {
765dc015
VP
2680 enum bp_loc_type new_type;
2681
2682 if (mr->attrib.mode != MEM_RW)
2683 new_type = bp_loc_hardware_breakpoint;
2684 else
2685 new_type = bp_loc_software_breakpoint;
2686
35df4500 2687 if (new_type != bl->loc_type)
765dc015
VP
2688 {
2689 static int said = 0;
cc59ec59 2690
35df4500 2691 bl->loc_type = new_type;
765dc015
VP
2692 if (!said)
2693 {
3e43a32a
MS
2694 fprintf_filtered (gdb_stdout,
2695 _("Note: automatically using "
2696 "hardware breakpoints for "
2697 "read-only addresses.\n"));
765dc015
VP
2698 said = 1;
2699 }
2700 }
2701 }
35df4500 2702 else if (bl->loc_type == bp_loc_software_breakpoint
0fec99e8
PA
2703 && mr->attrib.mode != MEM_RW)
2704 {
2705 fprintf_unfiltered (tmp_error_stream,
2706 _("Cannot insert breakpoint %d.\n"
2707 "Cannot set software breakpoint "
2708 "at read-only address %s\n"),
2709 bl->owner->number,
2710 paddress (bl->gdbarch, bl->address));
2711 return 1;
2712 }
765dc015
VP
2713 }
2714 }
2715
879bfdc2
DJ
2716 /* First check to see if we have to handle an overlay. */
2717 if (overlay_debugging == ovly_off
35df4500
TJB
2718 || bl->section == NULL
2719 || !(section_is_overlay (bl->section)))
879bfdc2
DJ
2720 {
2721 /* No overlay handling: just set the breakpoint. */
492d29ea 2722 TRY
dd61ec5c 2723 {
0000e5cc
PA
2724 int val;
2725
dd61ec5c 2726 val = bl->owner->ops->insert_location (bl);
0000e5cc
PA
2727 if (val)
2728 bp_err = GENERIC_ERROR;
dd61ec5c 2729 }
492d29ea 2730 CATCH (e, RETURN_MASK_ALL)
dd61ec5c 2731 {
0000e5cc
PA
2732 bp_err = e.error;
2733 bp_err_message = e.message;
dd61ec5c 2734 }
492d29ea 2735 END_CATCH
879bfdc2
DJ
2736 }
2737 else
2738 {
4a64f543 2739 /* This breakpoint is in an overlay section.
879bfdc2
DJ
2740 Shall we set a breakpoint at the LMA? */
2741 if (!overlay_events_enabled)
2742 {
2743 /* Yes -- overlay event support is not active,
2744 so we must try to set a breakpoint at the LMA.
2745 This will not work for a hardware breakpoint. */
35df4500 2746 if (bl->loc_type == bp_loc_hardware_breakpoint)
8a3fe4f8 2747 warning (_("hardware breakpoint %d not supported in overlay!"),
35df4500 2748 bl->owner->number);
879bfdc2
DJ
2749 else
2750 {
35df4500
TJB
2751 CORE_ADDR addr = overlay_unmapped_address (bl->address,
2752 bl->section);
879bfdc2 2753 /* Set a software (trap) breakpoint at the LMA. */
35df4500 2754 bl->overlay_target_info = bl->target_info;
0d5ed153 2755 bl->overlay_target_info.reqstd_address = addr;
0000e5cc
PA
2756
2757 /* No overlay handling: just set the breakpoint. */
492d29ea 2758 TRY
0000e5cc
PA
2759 {
2760 int val;
2761
579c6ad9 2762 bl->overlay_target_info.kind
cd6c3b4f
YQ
2763 = breakpoint_kind (bl, &addr);
2764 bl->overlay_target_info.placed_address = addr;
0000e5cc
PA
2765 val = target_insert_breakpoint (bl->gdbarch,
2766 &bl->overlay_target_info);
2767 if (val)
2768 bp_err = GENERIC_ERROR;
2769 }
492d29ea 2770 CATCH (e, RETURN_MASK_ALL)
0000e5cc
PA
2771 {
2772 bp_err = e.error;
2773 bp_err_message = e.message;
2774 }
492d29ea 2775 END_CATCH
0000e5cc
PA
2776
2777 if (bp_err != GDB_NO_ERROR)
99361f52 2778 fprintf_unfiltered (tmp_error_stream,
3e43a32a
MS
2779 "Overlay breakpoint %d "
2780 "failed: in ROM?\n",
35df4500 2781 bl->owner->number);
879bfdc2
DJ
2782 }
2783 }
2784 /* Shall we set a breakpoint at the VMA? */
35df4500 2785 if (section_is_mapped (bl->section))
879bfdc2
DJ
2786 {
2787 /* Yes. This overlay section is mapped into memory. */
492d29ea 2788 TRY
dd61ec5c 2789 {
0000e5cc
PA
2790 int val;
2791
dd61ec5c 2792 val = bl->owner->ops->insert_location (bl);
0000e5cc
PA
2793 if (val)
2794 bp_err = GENERIC_ERROR;
dd61ec5c 2795 }
492d29ea 2796 CATCH (e, RETURN_MASK_ALL)
dd61ec5c 2797 {
0000e5cc
PA
2798 bp_err = e.error;
2799 bp_err_message = e.message;
dd61ec5c 2800 }
492d29ea 2801 END_CATCH
879bfdc2
DJ
2802 }
2803 else
2804 {
2805 /* No. This breakpoint will not be inserted.
2806 No error, but do not mark the bp as 'inserted'. */
2807 return 0;
2808 }
2809 }
2810
0000e5cc 2811 if (bp_err != GDB_NO_ERROR)
879bfdc2
DJ
2812 {
2813 /* Can't set the breakpoint. */
0000e5cc
PA
2814
2815 /* In some cases, we might not be able to insert a
2816 breakpoint in a shared library that has already been
2817 removed, but we have not yet processed the shlib unload
2818 event. Unfortunately, some targets that implement
076855f9
PA
2819 breakpoint insertion themselves can't tell why the
2820 breakpoint insertion failed (e.g., the remote target
2821 doesn't define error codes), so we must treat generic
2822 errors as memory errors. */
0000e5cc 2823 if ((bp_err == GENERIC_ERROR || bp_err == MEMORY_ERROR)
076855f9 2824 && bl->loc_type == bp_loc_software_breakpoint
08351840 2825 && (solib_name_from_address (bl->pspace, bl->address)
d03de421
PA
2826 || shared_objfile_contains_address_p (bl->pspace,
2827 bl->address)))
879bfdc2 2828 {
4a64f543 2829 /* See also: disable_breakpoints_in_shlibs. */
35df4500 2830 bl->shlib_disabled = 1;
8d3788bd 2831 observer_notify_breakpoint_modified (bl->owner);
3fbb6ffa
TJB
2832 if (!*disabled_breaks)
2833 {
2834 fprintf_unfiltered (tmp_error_stream,
2835 "Cannot insert breakpoint %d.\n",
2836 bl->owner->number);
2837 fprintf_unfiltered (tmp_error_stream,
2838 "Temporarily disabling shared "
2839 "library breakpoints:\n");
2840 }
2841 *disabled_breaks = 1;
879bfdc2 2842 fprintf_unfiltered (tmp_error_stream,
35df4500 2843 "breakpoint #%d\n", bl->owner->number);
0000e5cc 2844 return 0;
879bfdc2
DJ
2845 }
2846 else
879bfdc2 2847 {
35df4500 2848 if (bl->loc_type == bp_loc_hardware_breakpoint)
879bfdc2 2849 {
0000e5cc
PA
2850 *hw_breakpoint_error = 1;
2851 *hw_bp_error_explained_already = bp_err_message != NULL;
dd61ec5c
MW
2852 fprintf_unfiltered (tmp_error_stream,
2853 "Cannot insert hardware breakpoint %d%s",
0000e5cc
PA
2854 bl->owner->number, bp_err_message ? ":" : ".\n");
2855 if (bp_err_message != NULL)
2856 fprintf_unfiltered (tmp_error_stream, "%s.\n", bp_err_message);
879bfdc2
DJ
2857 }
2858 else
2859 {
0000e5cc
PA
2860 if (bp_err_message == NULL)
2861 {
2862 char *message
2863 = memory_error_message (TARGET_XFER_E_IO,
2864 bl->gdbarch, bl->address);
2865 struct cleanup *old_chain = make_cleanup (xfree, message);
2866
2867 fprintf_unfiltered (tmp_error_stream,
2868 "Cannot insert breakpoint %d.\n"
2869 "%s\n",
2870 bl->owner->number, message);
2871 do_cleanups (old_chain);
2872 }
2873 else
2874 {
2875 fprintf_unfiltered (tmp_error_stream,
2876 "Cannot insert breakpoint %d: %s\n",
2877 bl->owner->number,
2878 bp_err_message);
2879 }
879bfdc2 2880 }
0000e5cc 2881 return 1;
879bfdc2
DJ
2882
2883 }
2884 }
2885 else
35df4500 2886 bl->inserted = 1;
879bfdc2 2887
0000e5cc 2888 return 0;
879bfdc2
DJ
2889 }
2890
35df4500 2891 else if (bl->loc_type == bp_loc_hardware_watchpoint
879bfdc2 2892 /* NOTE drow/2003-09-08: This state only exists for removing
4a64f543 2893 watchpoints. It's not clear that it's necessary... */
35df4500 2894 && bl->owner->disposition != disp_del_at_next_stop)
879bfdc2 2895 {
0000e5cc
PA
2896 int val;
2897
77b06cd7
TJB
2898 gdb_assert (bl->owner->ops != NULL
2899 && bl->owner->ops->insert_location != NULL);
2900
2901 val = bl->owner->ops->insert_location (bl);
85d721b8
PA
2902
2903 /* If trying to set a read-watchpoint, and it turns out it's not
2904 supported, try emulating one with an access watchpoint. */
35df4500 2905 if (val == 1 && bl->watchpoint_type == hw_read)
85d721b8
PA
2906 {
2907 struct bp_location *loc, **loc_temp;
2908
2909 /* But don't try to insert it, if there's already another
2910 hw_access location that would be considered a duplicate
2911 of this one. */
2912 ALL_BP_LOCATIONS (loc, loc_temp)
35df4500 2913 if (loc != bl
85d721b8 2914 && loc->watchpoint_type == hw_access
35df4500 2915 && watchpoint_locations_match (bl, loc))
85d721b8 2916 {
35df4500
TJB
2917 bl->duplicate = 1;
2918 bl->inserted = 1;
2919 bl->target_info = loc->target_info;
2920 bl->watchpoint_type = hw_access;
85d721b8
PA
2921 val = 0;
2922 break;
2923 }
2924
2925 if (val == 1)
2926 {
77b06cd7
TJB
2927 bl->watchpoint_type = hw_access;
2928 val = bl->owner->ops->insert_location (bl);
2929
2930 if (val)
2931 /* Back to the original value. */
2932 bl->watchpoint_type = hw_read;
85d721b8
PA
2933 }
2934 }
2935
35df4500 2936 bl->inserted = (val == 0);
879bfdc2
DJ
2937 }
2938
35df4500 2939 else if (bl->owner->type == bp_catchpoint)
879bfdc2 2940 {
0000e5cc
PA
2941 int val;
2942
77b06cd7
TJB
2943 gdb_assert (bl->owner->ops != NULL
2944 && bl->owner->ops->insert_location != NULL);
2945
2946 val = bl->owner->ops->insert_location (bl);
2947 if (val)
2948 {
2949 bl->owner->enable_state = bp_disabled;
2950
2951 if (val == 1)
2952 warning (_("\
2953Error inserting catchpoint %d: Your system does not support this type\n\
2954of catchpoint."), bl->owner->number);
2955 else
2956 warning (_("Error inserting catchpoint %d."), bl->owner->number);
2957 }
2958
2959 bl->inserted = (val == 0);
1640b821
DJ
2960
2961 /* We've already printed an error message if there was a problem
2962 inserting this catchpoint, and we've disabled the catchpoint,
2963 so just return success. */
2964 return 0;
879bfdc2
DJ
2965 }
2966
2967 return 0;
2968}
2969
6c95b8df
PA
2970/* This function is called when program space PSPACE is about to be
2971 deleted. It takes care of updating breakpoints to not reference
2972 PSPACE anymore. */
2973
2974void
2975breakpoint_program_space_exit (struct program_space *pspace)
2976{
2977 struct breakpoint *b, *b_temp;
876fa593 2978 struct bp_location *loc, **loc_temp;
6c95b8df
PA
2979
2980 /* Remove any breakpoint that was set through this program space. */
2981 ALL_BREAKPOINTS_SAFE (b, b_temp)
2982 {
2983 if (b->pspace == pspace)
2984 delete_breakpoint (b);
2985 }
2986
2987 /* Breakpoints set through other program spaces could have locations
2988 bound to PSPACE as well. Remove those. */
876fa593 2989 ALL_BP_LOCATIONS (loc, loc_temp)
6c95b8df
PA
2990 {
2991 struct bp_location *tmp;
2992
2993 if (loc->pspace == pspace)
2994 {
2bdf28a0 2995 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6c95b8df
PA
2996 if (loc->owner->loc == loc)
2997 loc->owner->loc = loc->next;
2998 else
2999 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
3000 if (tmp->next == loc)
3001 {
3002 tmp->next = loc->next;
3003 break;
3004 }
3005 }
3006 }
3007
3008 /* Now update the global location list to permanently delete the
3009 removed locations above. */
44702360 3010 update_global_location_list (UGLL_DONT_INSERT);
6c95b8df
PA
3011}
3012
74960c60
VP
3013/* Make sure all breakpoints are inserted in inferior.
3014 Throws exception on any error.
3015 A breakpoint that is already inserted won't be inserted
3016 again, so calling this function twice is safe. */
3017void
3018insert_breakpoints (void)
3019{
3020 struct breakpoint *bpt;
3021
3022 ALL_BREAKPOINTS (bpt)
3023 if (is_hardware_watchpoint (bpt))
3a5c3e22
PA
3024 {
3025 struct watchpoint *w = (struct watchpoint *) bpt;
3026
3027 update_watchpoint (w, 0 /* don't reparse. */);
3028 }
74960c60 3029
04086b45
PA
3030 /* Updating watchpoints creates new locations, so update the global
3031 location list. Explicitly tell ugll to insert locations and
3032 ignore breakpoints_always_inserted_mode. */
3033 update_global_location_list (UGLL_INSERT);
74960c60
VP
3034}
3035
20388dd6
YQ
3036/* Invoke CALLBACK for each of bp_location. */
3037
3038void
3039iterate_over_bp_locations (walk_bp_location_callback callback)
3040{
3041 struct bp_location *loc, **loc_tmp;
3042
3043 ALL_BP_LOCATIONS (loc, loc_tmp)
3044 {
3045 callback (loc, NULL);
3046 }
3047}
3048
b775012e
LM
3049/* This is used when we need to synch breakpoint conditions between GDB and the
3050 target. It is the case with deleting and disabling of breakpoints when using
3051 always-inserted mode. */
3052
3053static void
3054update_inserted_breakpoint_locations (void)
3055{
3056 struct bp_location *bl, **blp_tmp;
3057 int error_flag = 0;
3058 int val = 0;
3059 int disabled_breaks = 0;
3060 int hw_breakpoint_error = 0;
dd61ec5c 3061 int hw_bp_details_reported = 0;
b775012e 3062
d7e74731 3063 string_file tmp_error_stream;
b775012e
LM
3064
3065 /* Explicitly mark the warning -- this will only be printed if
3066 there was an error. */
d7e74731 3067 tmp_error_stream.puts ("Warning:\n");
b775012e 3068
d7e74731 3069 struct cleanup *cleanups = save_current_space_and_thread ();
b775012e
LM
3070
3071 ALL_BP_LOCATIONS (bl, blp_tmp)
3072 {
3073 /* We only want to update software breakpoints and hardware
3074 breakpoints. */
3075 if (!is_breakpoint (bl->owner))
3076 continue;
3077
3078 /* We only want to update locations that are already inserted
3079 and need updating. This is to avoid unwanted insertion during
3080 deletion of breakpoints. */
3081 if (!bl->inserted || (bl->inserted && !bl->needs_update))
3082 continue;
3083
3084 switch_to_program_space_and_thread (bl->pspace);
3085
3086 /* For targets that support global breakpoints, there's no need
3087 to select an inferior to insert breakpoint to. In fact, even
3088 if we aren't attached to any process yet, we should still
3089 insert breakpoints. */
f5656ead 3090 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
b775012e
LM
3091 && ptid_equal (inferior_ptid, null_ptid))
3092 continue;
3093
d7e74731 3094 val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
dd61ec5c 3095 &hw_breakpoint_error, &hw_bp_details_reported);
b775012e
LM
3096 if (val)
3097 error_flag = val;
3098 }
3099
3100 if (error_flag)
3101 {
3102 target_terminal_ours_for_output ();
3103 error_stream (tmp_error_stream);
3104 }
3105
3106 do_cleanups (cleanups);
3107}
3108
c30eee59 3109/* Used when starting or continuing the program. */
c906108c 3110
74960c60
VP
3111static void
3112insert_breakpoint_locations (void)
c906108c 3113{
a5606eee 3114 struct breakpoint *bpt;
35df4500 3115 struct bp_location *bl, **blp_tmp;
eacd795a 3116 int error_flag = 0;
c906108c 3117 int val = 0;
3fbb6ffa 3118 int disabled_breaks = 0;
81d0cc19 3119 int hw_breakpoint_error = 0;
dd61ec5c 3120 int hw_bp_error_explained_already = 0;
c906108c 3121
d7e74731
PA
3122 string_file tmp_error_stream;
3123
81d0cc19
GS
3124 /* Explicitly mark the warning -- this will only be printed if
3125 there was an error. */
d7e74731 3126 tmp_error_stream.puts ("Warning:\n");
6c95b8df 3127
d7e74731 3128 struct cleanup *cleanups = save_current_space_and_thread ();
6c95b8df 3129
35df4500 3130 ALL_BP_LOCATIONS (bl, blp_tmp)
879bfdc2 3131 {
b775012e 3132 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
879bfdc2
DJ
3133 continue;
3134
4a64f543
MS
3135 /* There is no point inserting thread-specific breakpoints if
3136 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3137 has BL->OWNER always non-NULL. */
35df4500 3138 if (bl->owner->thread != -1
5d5658a1 3139 && !valid_global_thread_id (bl->owner->thread))
f365de73
AS
3140 continue;
3141
35df4500 3142 switch_to_program_space_and_thread (bl->pspace);
6c95b8df
PA
3143
3144 /* For targets that support global breakpoints, there's no need
3145 to select an inferior to insert breakpoint to. In fact, even
3146 if we aren't attached to any process yet, we should still
3147 insert breakpoints. */
f5656ead 3148 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
6c95b8df
PA
3149 && ptid_equal (inferior_ptid, null_ptid))
3150 continue;
3151
d7e74731 3152 val = insert_bp_location (bl, &tmp_error_stream, &disabled_breaks,
dd61ec5c 3153 &hw_breakpoint_error, &hw_bp_error_explained_already);
879bfdc2 3154 if (val)
eacd795a 3155 error_flag = val;
879bfdc2 3156 }
c906108c 3157
4a64f543
MS
3158 /* If we failed to insert all locations of a watchpoint, remove
3159 them, as half-inserted watchpoint is of limited use. */
a5606eee
VP
3160 ALL_BREAKPOINTS (bpt)
3161 {
3162 int some_failed = 0;
3163 struct bp_location *loc;
3164
3165 if (!is_hardware_watchpoint (bpt))
3166 continue;
3167
d6b74ac4 3168 if (!breakpoint_enabled (bpt))
a5606eee 3169 continue;
74960c60
VP
3170
3171 if (bpt->disposition == disp_del_at_next_stop)
3172 continue;
a5606eee
VP
3173
3174 for (loc = bpt->loc; loc; loc = loc->next)
56710373 3175 if (!loc->inserted && should_be_inserted (loc))
a5606eee
VP
3176 {
3177 some_failed = 1;
3178 break;
3179 }
3180 if (some_failed)
3181 {
3182 for (loc = bpt->loc; loc; loc = loc->next)
3183 if (loc->inserted)
834c0d03 3184 remove_breakpoint (loc);
a5606eee
VP
3185
3186 hw_breakpoint_error = 1;
d7e74731
PA
3187 tmp_error_stream.printf ("Could not insert "
3188 "hardware watchpoint %d.\n",
3189 bpt->number);
eacd795a 3190 error_flag = -1;
a5606eee
VP
3191 }
3192 }
3193
eacd795a 3194 if (error_flag)
81d0cc19
GS
3195 {
3196 /* If a hardware breakpoint or watchpoint was inserted, add a
3197 message about possibly exhausted resources. */
dd61ec5c 3198 if (hw_breakpoint_error && !hw_bp_error_explained_already)
81d0cc19 3199 {
d7e74731 3200 tmp_error_stream.printf ("Could not insert hardware breakpoints:\n\
c6510018 3201You may have requested too many hardware breakpoints/watchpoints.\n");
81d0cc19 3202 }
81d0cc19
GS
3203 target_terminal_ours_for_output ();
3204 error_stream (tmp_error_stream);
3205 }
f7545552
TT
3206
3207 do_cleanups (cleanups);
c906108c
SS
3208}
3209
c30eee59
TJB
3210/* Used when the program stops.
3211 Returns zero if successful, or non-zero if there was a problem
3212 removing a breakpoint location. */
3213
c906108c 3214int
fba45db2 3215remove_breakpoints (void)
c906108c 3216{
35df4500 3217 struct bp_location *bl, **blp_tmp;
3a1bae8e 3218 int val = 0;
c906108c 3219
35df4500 3220 ALL_BP_LOCATIONS (bl, blp_tmp)
c5aa993b 3221 {
1e4d1764 3222 if (bl->inserted && !is_tracepoint (bl->owner))
834c0d03 3223 val |= remove_breakpoint (bl);
c5aa993b 3224 }
3a1bae8e 3225 return val;
c906108c
SS
3226}
3227
49fa26b0
PA
3228/* When a thread exits, remove breakpoints that are related to
3229 that thread. */
3230
3231static void
3232remove_threaded_breakpoints (struct thread_info *tp, int silent)
3233{
3234 struct breakpoint *b, *b_tmp;
3235
3236 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3237 {
5d5658a1 3238 if (b->thread == tp->global_num && user_breakpoint_p (b))
49fa26b0
PA
3239 {
3240 b->disposition = disp_del_at_next_stop;
3241
3242 printf_filtered (_("\
43792cf0
PA
3243Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3244 b->number, print_thread_id (tp));
49fa26b0
PA
3245
3246 /* Hide it from the user. */
3247 b->number = 0;
3248 }
3249 }
3250}
3251
6c95b8df
PA
3252/* Remove breakpoints of process PID. */
3253
3254int
3255remove_breakpoints_pid (int pid)
3256{
35df4500 3257 struct bp_location *bl, **blp_tmp;
6c95b8df
PA
3258 int val;
3259 struct inferior *inf = find_inferior_pid (pid);
3260
35df4500 3261 ALL_BP_LOCATIONS (bl, blp_tmp)
6c95b8df 3262 {
35df4500 3263 if (bl->pspace != inf->pspace)
6c95b8df
PA
3264 continue;
3265
fc126975 3266 if (bl->inserted && !bl->target_info.persist)
6c95b8df 3267 {
834c0d03 3268 val = remove_breakpoint (bl);
6c95b8df
PA
3269 if (val != 0)
3270 return val;
3271 }
3272 }
3273 return 0;
3274}
3275
c906108c 3276int
fba45db2 3277reattach_breakpoints (int pid)
c906108c 3278{
6c95b8df 3279 struct cleanup *old_chain;
35df4500 3280 struct bp_location *bl, **blp_tmp;
c906108c 3281 int val;
dd61ec5c 3282 int dummy1 = 0, dummy2 = 0, dummy3 = 0;
6c95b8df
PA
3283 struct inferior *inf;
3284 struct thread_info *tp;
3285
3286 tp = any_live_thread_of_process (pid);
3287 if (tp == NULL)
3288 return 1;
3289
3290 inf = find_inferior_pid (pid);
3291 old_chain = save_inferior_ptid ();
3292
3293 inferior_ptid = tp->ptid;
a4954f26 3294
d7e74731 3295 string_file tmp_error_stream;
c906108c 3296
35df4500 3297 ALL_BP_LOCATIONS (bl, blp_tmp)
c5aa993b 3298 {
35df4500 3299 if (bl->pspace != inf->pspace)
6c95b8df
PA
3300 continue;
3301
35df4500 3302 if (bl->inserted)
c5aa993b 3303 {
35df4500 3304 bl->inserted = 0;
d7e74731 3305 val = insert_bp_location (bl, &tmp_error_stream, &dummy1, &dummy2, &dummy3);
c5aa993b
JM
3306 if (val != 0)
3307 {
ce696e05 3308 do_cleanups (old_chain);
c5aa993b
JM
3309 return val;
3310 }
3311 }
3312 }
ce696e05 3313 do_cleanups (old_chain);
c906108c
SS
3314 return 0;
3315}
3316
e58b0e63
PA
3317static int internal_breakpoint_number = -1;
3318
84f4c1fe
PM
3319/* Set the breakpoint number of B, depending on the value of INTERNAL.
3320 If INTERNAL is non-zero, the breakpoint number will be populated
3321 from internal_breakpoint_number and that variable decremented.
e5dd4106 3322 Otherwise the breakpoint number will be populated from
84f4c1fe
PM
3323 breakpoint_count and that value incremented. Internal breakpoints
3324 do not set the internal var bpnum. */
3325static void
3326set_breakpoint_number (int internal, struct breakpoint *b)
3327{
3328 if (internal)
3329 b->number = internal_breakpoint_number--;
3330 else
3331 {
3332 set_breakpoint_count (breakpoint_count + 1);
3333 b->number = breakpoint_count;
3334 }
3335}
3336
e62c965a 3337static struct breakpoint *
a6d9a66e 3338create_internal_breakpoint (struct gdbarch *gdbarch,
06edf0c0 3339 CORE_ADDR address, enum bptype type,
c0a91b2b 3340 const struct breakpoint_ops *ops)
e62c965a 3341{
e62c965a
PP
3342 struct symtab_and_line sal;
3343 struct breakpoint *b;
3344
4a64f543 3345 init_sal (&sal); /* Initialize to zeroes. */
e62c965a
PP
3346
3347 sal.pc = address;
3348 sal.section = find_pc_overlay (sal.pc);
6c95b8df 3349 sal.pspace = current_program_space;
e62c965a 3350
06edf0c0 3351 b = set_raw_breakpoint (gdbarch, sal, type, ops);
e62c965a
PP
3352 b->number = internal_breakpoint_number--;
3353 b->disposition = disp_donttouch;
3354
3355 return b;
3356}
3357
17450429
PP
3358static const char *const longjmp_names[] =
3359 {
3360 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3361 };
3362#define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3363
3364/* Per-objfile data private to breakpoint.c. */
3365struct breakpoint_objfile_data
3366{
3367 /* Minimal symbol for "_ovly_debug_event" (if any). */
3b7344d5 3368 struct bound_minimal_symbol overlay_msym;
17450429
PP
3369
3370 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3b7344d5 3371 struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES];
17450429 3372
28106bc2
SDJ
3373 /* True if we have looked for longjmp probes. */
3374 int longjmp_searched;
3375
3376 /* SystemTap probe points for longjmp (if any). */
3377 VEC (probe_p) *longjmp_probes;
3378
17450429 3379 /* Minimal symbol for "std::terminate()" (if any). */
3b7344d5 3380 struct bound_minimal_symbol terminate_msym;
17450429
PP
3381
3382 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3b7344d5 3383 struct bound_minimal_symbol exception_msym;
28106bc2
SDJ
3384
3385 /* True if we have looked for exception probes. */
3386 int exception_searched;
3387
3388 /* SystemTap probe points for unwinding (if any). */
3389 VEC (probe_p) *exception_probes;
17450429
PP
3390};
3391
3392static const struct objfile_data *breakpoint_objfile_key;
3393
3394/* Minimal symbol not found sentinel. */
3395static struct minimal_symbol msym_not_found;
3396
3397/* Returns TRUE if MSYM point to the "not found" sentinel. */
3398
3399static int
3400msym_not_found_p (const struct minimal_symbol *msym)
3401{
3402 return msym == &msym_not_found;
3403}
3404
3405/* Return per-objfile data needed by breakpoint.c.
3406 Allocate the data if necessary. */
3407
3408static struct breakpoint_objfile_data *
3409get_breakpoint_objfile_data (struct objfile *objfile)
3410{
3411 struct breakpoint_objfile_data *bp_objfile_data;
3412
9a3c8263
SM
3413 bp_objfile_data = ((struct breakpoint_objfile_data *)
3414 objfile_data (objfile, breakpoint_objfile_key));
17450429
PP
3415 if (bp_objfile_data == NULL)
3416 {
8d749320
SM
3417 bp_objfile_data =
3418 XOBNEW (&objfile->objfile_obstack, struct breakpoint_objfile_data);
17450429
PP
3419
3420 memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
3421 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3422 }
3423 return bp_objfile_data;
3424}
3425
28106bc2
SDJ
3426static void
3427free_breakpoint_probes (struct objfile *obj, void *data)
3428{
9a3c8263
SM
3429 struct breakpoint_objfile_data *bp_objfile_data
3430 = (struct breakpoint_objfile_data *) data;
28106bc2
SDJ
3431
3432 VEC_free (probe_p, bp_objfile_data->longjmp_probes);
3433 VEC_free (probe_p, bp_objfile_data->exception_probes);
3434}
3435
e62c965a 3436static void
af02033e 3437create_overlay_event_breakpoint (void)
e62c965a 3438{
69de3c6a 3439 struct objfile *objfile;
af02033e 3440 const char *const func_name = "_ovly_debug_event";
e62c965a 3441
69de3c6a
PP
3442 ALL_OBJFILES (objfile)
3443 {
3444 struct breakpoint *b;
17450429
PP
3445 struct breakpoint_objfile_data *bp_objfile_data;
3446 CORE_ADDR addr;
67994074 3447 struct explicit_location explicit_loc;
69de3c6a 3448
17450429
PP
3449 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3450
3b7344d5 3451 if (msym_not_found_p (bp_objfile_data->overlay_msym.minsym))
17450429
PP
3452 continue;
3453
3b7344d5 3454 if (bp_objfile_data->overlay_msym.minsym == NULL)
17450429 3455 {
3b7344d5 3456 struct bound_minimal_symbol m;
17450429
PP
3457
3458 m = lookup_minimal_symbol_text (func_name, objfile);
3b7344d5 3459 if (m.minsym == NULL)
17450429
PP
3460 {
3461 /* Avoid future lookups in this objfile. */
3b7344d5 3462 bp_objfile_data->overlay_msym.minsym = &msym_not_found;
17450429
PP
3463 continue;
3464 }
3465 bp_objfile_data->overlay_msym = m;
3466 }
e62c965a 3467
77e371c0 3468 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
17450429 3469 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
06edf0c0
PA
3470 bp_overlay_event,
3471 &internal_breakpoint_ops);
67994074
KS
3472 initialize_explicit_location (&explicit_loc);
3473 explicit_loc.function_name = ASTRDUP (func_name);
d28cd78a 3474 b->location = new_explicit_location (&explicit_loc);
e62c965a 3475
69de3c6a
PP
3476 if (overlay_debugging == ovly_auto)
3477 {
3478 b->enable_state = bp_enabled;
3479 overlay_events_enabled = 1;
3480 }
3481 else
3482 {
3483 b->enable_state = bp_disabled;
3484 overlay_events_enabled = 0;
3485 }
e62c965a 3486 }
e62c965a
PP
3487}
3488
0fd8e87f 3489static void
af02033e 3490create_longjmp_master_breakpoint (void)
0fd8e87f 3491{
6c95b8df 3492 struct program_space *pspace;
6c95b8df
PA
3493 struct cleanup *old_chain;
3494
3495 old_chain = save_current_program_space ();
0fd8e87f 3496
6c95b8df 3497 ALL_PSPACES (pspace)
af02033e
PP
3498 {
3499 struct objfile *objfile;
3500
3501 set_current_program_space (pspace);
3502
3503 ALL_OBJFILES (objfile)
0fd8e87f 3504 {
af02033e
PP
3505 int i;
3506 struct gdbarch *gdbarch;
17450429 3507 struct breakpoint_objfile_data *bp_objfile_data;
0fd8e87f 3508
af02033e 3509 gdbarch = get_objfile_arch (objfile);
0fd8e87f 3510
17450429
PP
3511 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3512
28106bc2
SDJ
3513 if (!bp_objfile_data->longjmp_searched)
3514 {
25f9533e
SDJ
3515 VEC (probe_p) *ret;
3516
3517 ret = find_probes_in_objfile (objfile, "libc", "longjmp");
3518 if (ret != NULL)
3519 {
3520 /* We are only interested in checking one element. */
3521 struct probe *p = VEC_index (probe_p, ret, 0);
3522
3523 if (!can_evaluate_probe_arguments (p))
3524 {
3525 /* We cannot use the probe interface here, because it does
3526 not know how to evaluate arguments. */
3527 VEC_free (probe_p, ret);
3528 ret = NULL;
3529 }
3530 }
3531 bp_objfile_data->longjmp_probes = ret;
28106bc2
SDJ
3532 bp_objfile_data->longjmp_searched = 1;
3533 }
3534
3535 if (bp_objfile_data->longjmp_probes != NULL)
3536 {
3537 int i;
3538 struct probe *probe;
3539 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3540
3541 for (i = 0;
3542 VEC_iterate (probe_p,
3543 bp_objfile_data->longjmp_probes,
3544 i, probe);
3545 ++i)
3546 {
3547 struct breakpoint *b;
3548
729662a5
TT
3549 b = create_internal_breakpoint (gdbarch,
3550 get_probe_address (probe,
3551 objfile),
28106bc2
SDJ
3552 bp_longjmp_master,
3553 &internal_breakpoint_ops);
d28cd78a 3554 b->location = new_probe_location ("-probe-stap libc:longjmp");
28106bc2
SDJ
3555 b->enable_state = bp_disabled;
3556 }
3557
3558 continue;
3559 }
3560
0569175e
TSD
3561 if (!gdbarch_get_longjmp_target_p (gdbarch))
3562 continue;
3563
17450429 3564 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
af02033e
PP
3565 {
3566 struct breakpoint *b;
af02033e 3567 const char *func_name;
17450429 3568 CORE_ADDR addr;
67994074 3569 struct explicit_location explicit_loc;
6c95b8df 3570
3b7344d5 3571 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
af02033e 3572 continue;
0fd8e87f 3573
17450429 3574 func_name = longjmp_names[i];
3b7344d5 3575 if (bp_objfile_data->longjmp_msym[i].minsym == NULL)
17450429 3576 {
3b7344d5 3577 struct bound_minimal_symbol m;
17450429
PP
3578
3579 m = lookup_minimal_symbol_text (func_name, objfile);
3b7344d5 3580 if (m.minsym == NULL)
17450429
PP
3581 {
3582 /* Prevent future lookups in this objfile. */
3b7344d5 3583 bp_objfile_data->longjmp_msym[i].minsym = &msym_not_found;
17450429
PP
3584 continue;
3585 }
3586 bp_objfile_data->longjmp_msym[i] = m;
3587 }
3588
77e371c0 3589 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
06edf0c0
PA
3590 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3591 &internal_breakpoint_ops);
67994074
KS
3592 initialize_explicit_location (&explicit_loc);
3593 explicit_loc.function_name = ASTRDUP (func_name);
d28cd78a 3594 b->location = new_explicit_location (&explicit_loc);
af02033e
PP
3595 b->enable_state = bp_disabled;
3596 }
0fd8e87f 3597 }
af02033e 3598 }
6c95b8df
PA
3599
3600 do_cleanups (old_chain);
0fd8e87f
UW
3601}
3602
af02033e 3603/* Create a master std::terminate breakpoint. */
aa7d318d 3604static void
af02033e 3605create_std_terminate_master_breakpoint (void)
aa7d318d
TT
3606{
3607 struct program_space *pspace;
aa7d318d 3608 struct cleanup *old_chain;
af02033e 3609 const char *const func_name = "std::terminate()";
aa7d318d
TT
3610
3611 old_chain = save_current_program_space ();
3612
3613 ALL_PSPACES (pspace)
17450429
PP
3614 {
3615 struct objfile *objfile;
3616 CORE_ADDR addr;
3617
3618 set_current_program_space (pspace);
3619
aa7d318d
TT
3620 ALL_OBJFILES (objfile)
3621 {
3622 struct breakpoint *b;
17450429 3623 struct breakpoint_objfile_data *bp_objfile_data;
67994074 3624 struct explicit_location explicit_loc;
aa7d318d 3625
17450429 3626 bp_objfile_data = get_breakpoint_objfile_data (objfile);
aa7d318d 3627
3b7344d5 3628 if (msym_not_found_p (bp_objfile_data->terminate_msym.minsym))
17450429
PP
3629 continue;
3630
3b7344d5 3631 if (bp_objfile_data->terminate_msym.minsym == NULL)
17450429 3632 {
3b7344d5 3633 struct bound_minimal_symbol m;
17450429
PP
3634
3635 m = lookup_minimal_symbol (func_name, NULL, objfile);
3b7344d5
TT
3636 if (m.minsym == NULL || (MSYMBOL_TYPE (m.minsym) != mst_text
3637 && MSYMBOL_TYPE (m.minsym) != mst_file_text))
17450429
PP
3638 {
3639 /* Prevent future lookups in this objfile. */
3b7344d5 3640 bp_objfile_data->terminate_msym.minsym = &msym_not_found;
17450429
PP
3641 continue;
3642 }
3643 bp_objfile_data->terminate_msym = m;
3644 }
aa7d318d 3645
77e371c0 3646 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
17450429 3647 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
06edf0c0
PA
3648 bp_std_terminate_master,
3649 &internal_breakpoint_ops);
67994074
KS
3650 initialize_explicit_location (&explicit_loc);
3651 explicit_loc.function_name = ASTRDUP (func_name);
d28cd78a 3652 b->location = new_explicit_location (&explicit_loc);
aa7d318d
TT
3653 b->enable_state = bp_disabled;
3654 }
17450429
PP
3655 }
3656
aa7d318d
TT
3657 do_cleanups (old_chain);
3658}
3659
186c406b
TT
3660/* Install a master breakpoint on the unwinder's debug hook. */
3661
70221824 3662static void
186c406b
TT
3663create_exception_master_breakpoint (void)
3664{
3665 struct objfile *objfile;
17450429 3666 const char *const func_name = "_Unwind_DebugHook";
186c406b
TT
3667
3668 ALL_OBJFILES (objfile)
3669 {
17450429
PP
3670 struct breakpoint *b;
3671 struct gdbarch *gdbarch;
3672 struct breakpoint_objfile_data *bp_objfile_data;
3673 CORE_ADDR addr;
67994074 3674 struct explicit_location explicit_loc;
17450429
PP
3675
3676 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3677
28106bc2
SDJ
3678 /* We prefer the SystemTap probe point if it exists. */
3679 if (!bp_objfile_data->exception_searched)
3680 {
25f9533e
SDJ
3681 VEC (probe_p) *ret;
3682
3683 ret = find_probes_in_objfile (objfile, "libgcc", "unwind");
3684
3685 if (ret != NULL)
3686 {
3687 /* We are only interested in checking one element. */
3688 struct probe *p = VEC_index (probe_p, ret, 0);
3689
3690 if (!can_evaluate_probe_arguments (p))
3691 {
3692 /* We cannot use the probe interface here, because it does
3693 not know how to evaluate arguments. */
3694 VEC_free (probe_p, ret);
3695 ret = NULL;
3696 }
3697 }
3698 bp_objfile_data->exception_probes = ret;
28106bc2
SDJ
3699 bp_objfile_data->exception_searched = 1;
3700 }
3701
3702 if (bp_objfile_data->exception_probes != NULL)
3703 {
3704 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3705 int i;
3706 struct probe *probe;
3707
3708 for (i = 0;
3709 VEC_iterate (probe_p,
3710 bp_objfile_data->exception_probes,
3711 i, probe);
3712 ++i)
3713 {
3714 struct breakpoint *b;
3715
729662a5
TT
3716 b = create_internal_breakpoint (gdbarch,
3717 get_probe_address (probe,
3718 objfile),
28106bc2
SDJ
3719 bp_exception_master,
3720 &internal_breakpoint_ops);
d28cd78a 3721 b->location = new_probe_location ("-probe-stap libgcc:unwind");
28106bc2
SDJ
3722 b->enable_state = bp_disabled;
3723 }
3724
3725 continue;
3726 }
3727
3728 /* Otherwise, try the hook function. */
3729
3b7344d5 3730 if (msym_not_found_p (bp_objfile_data->exception_msym.minsym))
17450429
PP
3731 continue;
3732
3733 gdbarch = get_objfile_arch (objfile);
186c406b 3734
3b7344d5 3735 if (bp_objfile_data->exception_msym.minsym == NULL)
186c406b 3736 {
3b7344d5 3737 struct bound_minimal_symbol debug_hook;
186c406b 3738
17450429 3739 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3b7344d5 3740 if (debug_hook.minsym == NULL)
17450429 3741 {
3b7344d5 3742 bp_objfile_data->exception_msym.minsym = &msym_not_found;
17450429
PP
3743 continue;
3744 }
3745
3746 bp_objfile_data->exception_msym = debug_hook;
186c406b 3747 }
17450429 3748
77e371c0 3749 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
17450429
PP
3750 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3751 &current_target);
06edf0c0
PA
3752 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3753 &internal_breakpoint_ops);
67994074
KS
3754 initialize_explicit_location (&explicit_loc);
3755 explicit_loc.function_name = ASTRDUP (func_name);
d28cd78a 3756 b->location = new_explicit_location (&explicit_loc);
17450429 3757 b->enable_state = bp_disabled;
186c406b 3758 }
186c406b
TT
3759}
3760
9ef9e6a6
KS
3761/* Does B have a location spec? */
3762
3763static int
3764breakpoint_event_location_empty_p (const struct breakpoint *b)
3765{
d28cd78a 3766 return b->location != NULL && event_location_empty_p (b->location.get ());
9ef9e6a6
KS
3767}
3768
c906108c 3769void
fba45db2 3770update_breakpoints_after_exec (void)
c906108c 3771{
35df4500 3772 struct breakpoint *b, *b_tmp;
876fa593 3773 struct bp_location *bploc, **bplocp_tmp;
c906108c 3774
25b22b0a
PA
3775 /* We're about to delete breakpoints from GDB's lists. If the
3776 INSERTED flag is true, GDB will try to lift the breakpoints by
3777 writing the breakpoints' "shadow contents" back into memory. The
3778 "shadow contents" are NOT valid after an exec, so GDB should not
3779 do that. Instead, the target is responsible from marking
3780 breakpoints out as soon as it detects an exec. We don't do that
3781 here instead, because there may be other attempts to delete
3782 breakpoints after detecting an exec and before reaching here. */
876fa593 3783 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
6c95b8df
PA
3784 if (bploc->pspace == current_program_space)
3785 gdb_assert (!bploc->inserted);
c906108c 3786
35df4500 3787 ALL_BREAKPOINTS_SAFE (b, b_tmp)
c5aa993b 3788 {
6c95b8df
PA
3789 if (b->pspace != current_program_space)
3790 continue;
3791
4a64f543 3792 /* Solib breakpoints must be explicitly reset after an exec(). */
c5aa993b
JM
3793 if (b->type == bp_shlib_event)
3794 {
3795 delete_breakpoint (b);
3796 continue;
3797 }
c906108c 3798
4a64f543 3799 /* JIT breakpoints must be explicitly reset after an exec(). */
4efc6507
DE
3800 if (b->type == bp_jit_event)
3801 {
3802 delete_breakpoint (b);
3803 continue;
3804 }
3805
1900040c 3806 /* Thread event breakpoints must be set anew after an exec(),
0fd8e87f
UW
3807 as must overlay event and longjmp master breakpoints. */
3808 if (b->type == bp_thread_event || b->type == bp_overlay_event
186c406b
TT
3809 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3810 || b->type == bp_exception_master)
c4093a6a
JM
3811 {
3812 delete_breakpoint (b);
3813 continue;
3814 }
3815
4a64f543 3816 /* Step-resume breakpoints are meaningless after an exec(). */
2c03e5be 3817 if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
c5aa993b
JM
3818 {
3819 delete_breakpoint (b);
3820 continue;
3821 }
3822
7c16b83e
PA
3823 /* Just like single-step breakpoints. */
3824 if (b->type == bp_single_step)
3825 {
3826 delete_breakpoint (b);
3827 continue;
3828 }
3829
611c83ae
PA
3830 /* Longjmp and longjmp-resume breakpoints are also meaningless
3831 after an exec. */
186c406b 3832 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
e2e4d78b 3833 || b->type == bp_longjmp_call_dummy
186c406b 3834 || b->type == bp_exception || b->type == bp_exception_resume)
611c83ae
PA
3835 {
3836 delete_breakpoint (b);
3837 continue;
3838 }
3839
ce78b96d
JB
3840 if (b->type == bp_catchpoint)
3841 {
3842 /* For now, none of the bp_catchpoint breakpoints need to
3843 do anything at this point. In the future, if some of
3844 the catchpoints need to something, we will need to add
3845 a new method, and call this method from here. */
3846 continue;
3847 }
3848
c5aa993b
JM
3849 /* bp_finish is a special case. The only way we ought to be able
3850 to see one of these when an exec() has happened, is if the user
3851 caught a vfork, and then said "finish". Ordinarily a finish just
3852 carries them to the call-site of the current callee, by setting
3853 a temporary bp there and resuming. But in this case, the finish
3854 will carry them entirely through the vfork & exec.
3855
3856 We don't want to allow a bp_finish to remain inserted now. But
3857 we can't safely delete it, 'cause finish_command has a handle to
3858 the bp on a bpstat, and will later want to delete it. There's a
3859 chance (and I've seen it happen) that if we delete the bp_finish
3860 here, that its storage will get reused by the time finish_command
3861 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3862 We really must allow finish_command to delete a bp_finish.
3863
e5dd4106 3864 In the absence of a general solution for the "how do we know
53a5351d
JM
3865 it's safe to delete something others may have handles to?"
3866 problem, what we'll do here is just uninsert the bp_finish, and
3867 let finish_command delete it.
3868
3869 (We know the bp_finish is "doomed" in the sense that it's
3870 momentary, and will be deleted as soon as finish_command sees
3871 the inferior stopped. So it doesn't matter that the bp's
3872 address is probably bogus in the new a.out, unlike e.g., the
3873 solib breakpoints.) */
c5aa993b 3874
c5aa993b
JM
3875 if (b->type == bp_finish)
3876 {
3877 continue;
3878 }
3879
3880 /* Without a symbolic address, we have little hope of the
3881 pre-exec() address meaning the same thing in the post-exec()
4a64f543 3882 a.out. */
9ef9e6a6 3883 if (breakpoint_event_location_empty_p (b))
c5aa993b
JM
3884 {
3885 delete_breakpoint (b);
3886 continue;
3887 }
c5aa993b 3888 }
c906108c
SS
3889}
3890
3891int
d80ee84f 3892detach_breakpoints (ptid_t ptid)
c906108c 3893{
35df4500 3894 struct bp_location *bl, **blp_tmp;
3a1bae8e 3895 int val = 0;
ce696e05 3896 struct cleanup *old_chain = save_inferior_ptid ();
6c95b8df 3897 struct inferior *inf = current_inferior ();
c5aa993b 3898
dfd4cc63 3899 if (ptid_get_pid (ptid) == ptid_get_pid (inferior_ptid))
8a3fe4f8 3900 error (_("Cannot detach breakpoints of inferior_ptid"));
c5aa993b 3901
6c95b8df 3902 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
d80ee84f 3903 inferior_ptid = ptid;
35df4500 3904 ALL_BP_LOCATIONS (bl, blp_tmp)
c5aa993b 3905 {
35df4500 3906 if (bl->pspace != inf->pspace)
6c95b8df
PA
3907 continue;
3908
bd9673a4
PW
3909 /* This function must physically remove breakpoints locations
3910 from the specified ptid, without modifying the breakpoint
3911 package's state. Locations of type bp_loc_other are only
3912 maintained at GDB side. So, there is no need to remove
3913 these bp_loc_other locations. Moreover, removing these
3914 would modify the breakpoint package's state. */
3915 if (bl->loc_type == bp_loc_other)
3916 continue;
3917
35df4500 3918 if (bl->inserted)
b2b6a7da 3919 val |= remove_breakpoint_1 (bl, DETACH_BREAKPOINT);
c5aa993b 3920 }
d03285ec 3921
ce696e05 3922 do_cleanups (old_chain);
3a1bae8e 3923 return val;
c906108c
SS
3924}
3925
35df4500 3926/* Remove the breakpoint location BL from the current address space.
6c95b8df
PA
3927 Note that this is used to detach breakpoints from a child fork.
3928 When we get here, the child isn't in the inferior list, and neither
3929 do we have objects to represent its address space --- we should
35df4500 3930 *not* look at bl->pspace->aspace here. */
6c95b8df 3931
c906108c 3932static int
b2b6a7da 3933remove_breakpoint_1 (struct bp_location *bl, enum remove_bp_reason reason)
c906108c
SS
3934{
3935 int val;
c5aa993b 3936
35df4500
TJB
3937 /* BL is never in moribund_locations by our callers. */
3938 gdb_assert (bl->owner != NULL);
2bdf28a0 3939
74960c60
VP
3940 /* The type of none suggests that owner is actually deleted.
3941 This should not ever happen. */
35df4500 3942 gdb_assert (bl->owner->type != bp_none);
0bde7532 3943
35df4500
TJB
3944 if (bl->loc_type == bp_loc_software_breakpoint
3945 || bl->loc_type == bp_loc_hardware_breakpoint)
c906108c 3946 {
c02f5703
MS
3947 /* "Normal" instruction breakpoint: either the standard
3948 trap-instruction bp (bp_breakpoint), or a
3949 bp_hardware_breakpoint. */
3950
3951 /* First check to see if we have to handle an overlay. */
3952 if (overlay_debugging == ovly_off
35df4500
TJB
3953 || bl->section == NULL
3954 || !(section_is_overlay (bl->section)))
c02f5703
MS
3955 {
3956 /* No overlay handling: just remove the breakpoint. */
08351840
PA
3957
3958 /* If we're trying to uninsert a memory breakpoint that we
3959 know is set in a dynamic object that is marked
3960 shlib_disabled, then either the dynamic object was
3961 removed with "remove-symbol-file" or with
3962 "nosharedlibrary". In the former case, we don't know
3963 whether another dynamic object might have loaded over the
3964 breakpoint's address -- the user might well let us know
3965 about it next with add-symbol-file (the whole point of
d03de421 3966 add-symbol-file is letting the user manually maintain a
08351840
PA
3967 list of dynamically loaded objects). If we have the
3968 breakpoint's shadow memory, that is, this is a software
3969 breakpoint managed by GDB, check whether the breakpoint
3970 is still inserted in memory, to avoid overwriting wrong
3971 code with stale saved shadow contents. Note that HW
3972 breakpoints don't have shadow memory, as they're
3973 implemented using a mechanism that is not dependent on
3974 being able to modify the target's memory, and as such
3975 they should always be removed. */
3976 if (bl->shlib_disabled
3977 && bl->target_info.shadow_len != 0
3978 && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info))
3979 val = 0;
3980 else
73971819 3981 val = bl->owner->ops->remove_location (bl, reason);
c02f5703 3982 }
c906108c
SS
3983 else
3984 {
4a64f543 3985 /* This breakpoint is in an overlay section.
c02f5703
MS
3986 Did we set a breakpoint at the LMA? */
3987 if (!overlay_events_enabled)
3988 {
3989 /* Yes -- overlay event support is not active, so we
3990 should have set a breakpoint at the LMA. Remove it.
3991 */
c02f5703
MS
3992 /* Ignore any failures: if the LMA is in ROM, we will
3993 have already warned when we failed to insert it. */
35df4500
TJB
3994 if (bl->loc_type == bp_loc_hardware_breakpoint)
3995 target_remove_hw_breakpoint (bl->gdbarch,
3996 &bl->overlay_target_info);
c02f5703 3997 else
35df4500 3998 target_remove_breakpoint (bl->gdbarch,
73971819
PA
3999 &bl->overlay_target_info,
4000 reason);
c02f5703
MS
4001 }
4002 /* Did we set a breakpoint at the VMA?
4003 If so, we will have marked the breakpoint 'inserted'. */
35df4500 4004 if (bl->inserted)
c906108c 4005 {
c02f5703
MS
4006 /* Yes -- remove it. Previously we did not bother to
4007 remove the breakpoint if the section had been
4008 unmapped, but let's not rely on that being safe. We
4009 don't know what the overlay manager might do. */
aa67235e
UW
4010
4011 /* However, we should remove *software* breakpoints only
4012 if the section is still mapped, or else we overwrite
4013 wrong code with the saved shadow contents. */
348d480f
PA
4014 if (bl->loc_type == bp_loc_hardware_breakpoint
4015 || section_is_mapped (bl->section))
73971819 4016 val = bl->owner->ops->remove_location (bl, reason);
aa67235e
UW
4017 else
4018 val = 0;
c906108c 4019 }
c02f5703
MS
4020 else
4021 {
4022 /* No -- not inserted, so no need to remove. No error. */
4023 val = 0;
4024 }
c906108c 4025 }
879d1e6b 4026
08351840
PA
4027 /* In some cases, we might not be able to remove a breakpoint in
4028 a shared library that has already been removed, but we have
4029 not yet processed the shlib unload event. Similarly for an
4030 unloaded add-symbol-file object - the user might not yet have
4031 had the chance to remove-symbol-file it. shlib_disabled will
4032 be set if the library/object has already been removed, but
4033 the breakpoint hasn't been uninserted yet, e.g., after
4034 "nosharedlibrary" or "remove-symbol-file" with breakpoints
4035 always-inserted mode. */
076855f9 4036 if (val
08351840
PA
4037 && (bl->loc_type == bp_loc_software_breakpoint
4038 && (bl->shlib_disabled
4039 || solib_name_from_address (bl->pspace, bl->address)
d03de421
PA
4040 || shared_objfile_contains_address_p (bl->pspace,
4041 bl->address))))
879d1e6b
UW
4042 val = 0;
4043
c906108c
SS
4044 if (val)
4045 return val;
b2b6a7da 4046 bl->inserted = (reason == DETACH_BREAKPOINT);
c906108c 4047 }
35df4500 4048 else if (bl->loc_type == bp_loc_hardware_watchpoint)
c906108c 4049 {
77b06cd7
TJB
4050 gdb_assert (bl->owner->ops != NULL
4051 && bl->owner->ops->remove_location != NULL);
4052
b2b6a7da 4053 bl->inserted = (reason == DETACH_BREAKPOINT);
73971819 4054 bl->owner->ops->remove_location (bl, reason);
2e70b7b9 4055
c906108c 4056 /* Failure to remove any of the hardware watchpoints comes here. */
b2b6a7da 4057 if (reason == REMOVE_BREAKPOINT && bl->inserted)
8a3fe4f8 4058 warning (_("Could not remove hardware watchpoint %d."),
35df4500 4059 bl->owner->number);
c906108c 4060 }
35df4500
TJB
4061 else if (bl->owner->type == bp_catchpoint
4062 && breakpoint_enabled (bl->owner)
4063 && !bl->duplicate)
ce78b96d 4064 {
77b06cd7
TJB
4065 gdb_assert (bl->owner->ops != NULL
4066 && bl->owner->ops->remove_location != NULL);
ce78b96d 4067
73971819 4068 val = bl->owner->ops->remove_location (bl, reason);
ce78b96d
JB
4069 if (val)
4070 return val;
77b06cd7 4071
b2b6a7da 4072 bl->inserted = (reason == DETACH_BREAKPOINT);
ce78b96d 4073 }
c906108c
SS
4074
4075 return 0;
4076}
4077
6c95b8df 4078static int
834c0d03 4079remove_breakpoint (struct bp_location *bl)
6c95b8df
PA
4080{
4081 int ret;
4082 struct cleanup *old_chain;
4083
35df4500
TJB
4084 /* BL is never in moribund_locations by our callers. */
4085 gdb_assert (bl->owner != NULL);
2bdf28a0 4086
6c95b8df
PA
4087 /* The type of none suggests that owner is actually deleted.
4088 This should not ever happen. */
35df4500 4089 gdb_assert (bl->owner->type != bp_none);
6c95b8df
PA
4090
4091 old_chain = save_current_space_and_thread ();
4092
35df4500 4093 switch_to_program_space_and_thread (bl->pspace);
6c95b8df 4094
b2b6a7da 4095 ret = remove_breakpoint_1 (bl, REMOVE_BREAKPOINT);
6c95b8df
PA
4096
4097 do_cleanups (old_chain);
4098 return ret;
4099}
4100
c906108c
SS
4101/* Clear the "inserted" flag in all breakpoints. */
4102
25b22b0a 4103void
fba45db2 4104mark_breakpoints_out (void)
c906108c 4105{
35df4500 4106 struct bp_location *bl, **blp_tmp;
c906108c 4107
35df4500 4108 ALL_BP_LOCATIONS (bl, blp_tmp)
66c4b3e8 4109 if (bl->pspace == current_program_space)
35df4500 4110 bl->inserted = 0;
c906108c
SS
4111}
4112
53a5351d
JM
4113/* Clear the "inserted" flag in all breakpoints and delete any
4114 breakpoints which should go away between runs of the program.
c906108c
SS
4115
4116 Plus other such housekeeping that has to be done for breakpoints
4117 between runs.
4118
53a5351d
JM
4119 Note: this function gets called at the end of a run (by
4120 generic_mourn_inferior) and when a run begins (by
4a64f543 4121 init_wait_for_inferior). */
c906108c
SS
4122
4123
4124
4125void
fba45db2 4126breakpoint_init_inferior (enum inf_context context)
c906108c 4127{
35df4500 4128 struct breakpoint *b, *b_tmp;
870f88f7 4129 struct bp_location *bl;
1c5cfe86 4130 int ix;
6c95b8df 4131 struct program_space *pspace = current_program_space;
c906108c 4132
50c71eaf
PA
4133 /* If breakpoint locations are shared across processes, then there's
4134 nothing to do. */
f5656ead 4135 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
50c71eaf
PA
4136 return;
4137
1a853c52 4138 mark_breakpoints_out ();
075f6582 4139
35df4500 4140 ALL_BREAKPOINTS_SAFE (b, b_tmp)
c5aa993b 4141 {
6c95b8df
PA
4142 if (b->loc && b->loc->pspace != pspace)
4143 continue;
4144
c5aa993b
JM
4145 switch (b->type)
4146 {
4147 case bp_call_dummy:
e2e4d78b 4148 case bp_longjmp_call_dummy:
c906108c 4149
c5aa993b 4150 /* If the call dummy breakpoint is at the entry point it will
ab92d69b
PA
4151 cause problems when the inferior is rerun, so we better get
4152 rid of it. */
4153
4154 case bp_watchpoint_scope:
4155
4156 /* Also get rid of scope breakpoints. */
4157
4158 case bp_shlib_event:
4159
4160 /* Also remove solib event breakpoints. Their addresses may
4161 have changed since the last time we ran the program.
4162 Actually we may now be debugging against different target;
4163 and so the solib backend that installed this breakpoint may
4164 not be used in by the target. E.g.,
4165
4166 (gdb) file prog-linux
4167 (gdb) run # native linux target
4168 ...
4169 (gdb) kill
4170 (gdb) file prog-win.exe
4171 (gdb) tar rem :9999 # remote Windows gdbserver.
4172 */
c906108c 4173
f59f708a
PA
4174 case bp_step_resume:
4175
4176 /* Also remove step-resume breakpoints. */
4177
7c16b83e
PA
4178 case bp_single_step:
4179
4180 /* Also remove single-step breakpoints. */
4181
c5aa993b
JM
4182 delete_breakpoint (b);
4183 break;
c906108c 4184
c5aa993b
JM
4185 case bp_watchpoint:
4186 case bp_hardware_watchpoint:
4187 case bp_read_watchpoint:
4188 case bp_access_watchpoint:
3a5c3e22
PA
4189 {
4190 struct watchpoint *w = (struct watchpoint *) b;
c906108c 4191
3a5c3e22
PA
4192 /* Likewise for watchpoints on local expressions. */
4193 if (w->exp_valid_block != NULL)
4194 delete_breakpoint (b);
63000888 4195 else
3a5c3e22 4196 {
63000888
PA
4197 /* Get rid of existing locations, which are no longer
4198 valid. New ones will be created in
4199 update_watchpoint, when the inferior is restarted.
4200 The next update_global_location_list call will
4201 garbage collect them. */
4202 b->loc = NULL;
4203
4204 if (context == inf_starting)
4205 {
4206 /* Reset val field to force reread of starting value in
4207 insert_breakpoints. */
4208 if (w->val)
4209 value_free (w->val);
4210 w->val = NULL;
4211 w->val_valid = 0;
4212 }
4213 }
3a5c3e22 4214 }
c5aa993b
JM
4215 break;
4216 default:
c5aa993b
JM
4217 break;
4218 }
4219 }
1c5cfe86
PA
4220
4221 /* Get rid of the moribund locations. */
35df4500
TJB
4222 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
4223 decref_bp_location (&bl);
1c5cfe86 4224 VEC_free (bp_location_p, moribund_locations);
c906108c
SS
4225}
4226
6c95b8df
PA
4227/* These functions concern about actual breakpoints inserted in the
4228 target --- to e.g. check if we need to do decr_pc adjustment or if
4229 we need to hop over the bkpt --- so we check for address space
4230 match, not program space. */
4231
c2c6d25f
JM
4232/* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4233 exists at PC. It returns ordinary_breakpoint_here if it's an
4234 ordinary breakpoint, or permanent_breakpoint_here if it's a
4235 permanent breakpoint.
4236 - When continuing from a location with an ordinary breakpoint, we
4237 actually single step once before calling insert_breakpoints.
e5dd4106 4238 - When continuing from a location with a permanent breakpoint, we
c2c6d25f
JM
4239 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4240 the target, to advance the PC past the breakpoint. */
c906108c 4241
c2c6d25f 4242enum breakpoint_here
6c95b8df 4243breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
c906108c 4244{
35df4500 4245 struct bp_location *bl, **blp_tmp;
c2c6d25f 4246 int any_breakpoint_here = 0;
c906108c 4247
35df4500 4248 ALL_BP_LOCATIONS (bl, blp_tmp)
075f6582 4249 {
35df4500
TJB
4250 if (bl->loc_type != bp_loc_software_breakpoint
4251 && bl->loc_type != bp_loc_hardware_breakpoint)
075f6582
DJ
4252 continue;
4253
f1310107 4254 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
35df4500 4255 if ((breakpoint_enabled (bl->owner)
1a853c52 4256 || bl->permanent)
f1310107 4257 && breakpoint_location_address_match (bl, aspace, pc))
075f6582
DJ
4258 {
4259 if (overlay_debugging
35df4500
TJB
4260 && section_is_overlay (bl->section)
4261 && !section_is_mapped (bl->section))
075f6582 4262 continue; /* unmapped overlay -- can't be a match */
1a853c52 4263 else if (bl->permanent)
075f6582
DJ
4264 return permanent_breakpoint_here;
4265 else
4266 any_breakpoint_here = 1;
4267 }
4268 }
c906108c 4269
f486487f 4270 return any_breakpoint_here ? ordinary_breakpoint_here : no_breakpoint_here;
c906108c
SS
4271}
4272
d35ae833
PA
4273/* See breakpoint.h. */
4274
4275int
4276breakpoint_in_range_p (struct address_space *aspace,
4277 CORE_ADDR addr, ULONGEST len)
4278{
4279 struct bp_location *bl, **blp_tmp;
4280
4281 ALL_BP_LOCATIONS (bl, blp_tmp)
4282 {
4283 if (bl->loc_type != bp_loc_software_breakpoint
4284 && bl->loc_type != bp_loc_hardware_breakpoint)
4285 continue;
4286
4287 if ((breakpoint_enabled (bl->owner)
4288 || bl->permanent)
4289 && breakpoint_location_address_range_overlap (bl, aspace,
4290 addr, len))
4291 {
4292 if (overlay_debugging
4293 && section_is_overlay (bl->section)
4294 && !section_is_mapped (bl->section))
4295 {
4296 /* Unmapped overlay -- can't be a match. */
4297 continue;
4298 }
4299
4300 return 1;
4301 }
4302 }
4303
4304 return 0;
4305}
4306
1c5cfe86
PA
4307/* Return true if there's a moribund breakpoint at PC. */
4308
4309int
6c95b8df 4310moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
1c5cfe86
PA
4311{
4312 struct bp_location *loc;
4313 int ix;
4314
4315 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
f1310107 4316 if (breakpoint_location_address_match (loc, aspace, pc))
1c5cfe86
PA
4317 return 1;
4318
4319 return 0;
4320}
c2c6d25f 4321
f7ce857f
PA
4322/* Returns non-zero iff BL is inserted at PC, in address space
4323 ASPACE. */
4324
4325static int
4326bp_location_inserted_here_p (struct bp_location *bl,
4327 struct address_space *aspace, CORE_ADDR pc)
4328{
4329 if (bl->inserted
4330 && breakpoint_address_match (bl->pspace->aspace, bl->address,
4331 aspace, pc))
4332 {
4333 if (overlay_debugging
4334 && section_is_overlay (bl->section)
4335 && !section_is_mapped (bl->section))
4336 return 0; /* unmapped overlay -- can't be a match */
4337 else
4338 return 1;
4339 }
4340 return 0;
4341}
4342
a1fd2fa5 4343/* Returns non-zero iff there's a breakpoint inserted at PC. */
c906108c
SS
4344
4345int
a1fd2fa5 4346breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
c906108c 4347{
f7ce857f 4348 struct bp_location **blp, **blp_tmp = NULL;
c906108c 4349
f7ce857f 4350 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
c5aa993b 4351 {
f7ce857f
PA
4352 struct bp_location *bl = *blp;
4353
35df4500
TJB
4354 if (bl->loc_type != bp_loc_software_breakpoint
4355 && bl->loc_type != bp_loc_hardware_breakpoint)
075f6582
DJ
4356 continue;
4357
f7ce857f
PA
4358 if (bp_location_inserted_here_p (bl, aspace, pc))
4359 return 1;
c5aa993b 4360 }
c36b740a
VP
4361 return 0;
4362}
4363
a1fd2fa5
PA
4364/* This function returns non-zero iff there is a software breakpoint
4365 inserted at PC. */
c36b740a
VP
4366
4367int
a1fd2fa5
PA
4368software_breakpoint_inserted_here_p (struct address_space *aspace,
4369 CORE_ADDR pc)
4fa8626c 4370{
f7ce857f 4371 struct bp_location **blp, **blp_tmp = NULL;
4fa8626c 4372
f7ce857f 4373 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4fa8626c 4374 {
f7ce857f
PA
4375 struct bp_location *bl = *blp;
4376
35df4500 4377 if (bl->loc_type != bp_loc_software_breakpoint)
4fa8626c
DJ
4378 continue;
4379
f7ce857f
PA
4380 if (bp_location_inserted_here_p (bl, aspace, pc))
4381 return 1;
4fa8626c
DJ
4382 }
4383
4384 return 0;
9c02b525
PA
4385}
4386
4387/* See breakpoint.h. */
4388
4389int
4390hardware_breakpoint_inserted_here_p (struct address_space *aspace,
4391 CORE_ADDR pc)
4392{
4393 struct bp_location **blp, **blp_tmp = NULL;
9c02b525
PA
4394
4395 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4396 {
4397 struct bp_location *bl = *blp;
4398
4399 if (bl->loc_type != bp_loc_hardware_breakpoint)
4400 continue;
4401
4402 if (bp_location_inserted_here_p (bl, aspace, pc))
4403 return 1;
4404 }
4405
4406 return 0;
4fa8626c
DJ
4407}
4408
9093389c
PA
4409int
4410hardware_watchpoint_inserted_in_range (struct address_space *aspace,
4411 CORE_ADDR addr, ULONGEST len)
4412{
4413 struct breakpoint *bpt;
4414
4415 ALL_BREAKPOINTS (bpt)
4416 {
4417 struct bp_location *loc;
4418
4419 if (bpt->type != bp_hardware_watchpoint
4420 && bpt->type != bp_access_watchpoint)
4421 continue;
4422
4423 if (!breakpoint_enabled (bpt))
4424 continue;
4425
4426 for (loc = bpt->loc; loc; loc = loc->next)
4427 if (loc->pspace->aspace == aspace && loc->inserted)
4428 {
4429 CORE_ADDR l, h;
4430
4431 /* Check for intersection. */
768adc05
PA
4432 l = std::max<CORE_ADDR> (loc->address, addr);
4433 h = std::min<CORE_ADDR> (loc->address + loc->length, addr + len);
9093389c
PA
4434 if (l < h)
4435 return 1;
4436 }
4437 }
4438 return 0;
4439}
c906108c 4440\f
c5aa993b 4441
c906108c
SS
4442/* bpstat stuff. External routines' interfaces are documented
4443 in breakpoint.h. */
4444
4445int
c326b90e 4446is_catchpoint (struct breakpoint *ep)
c906108c 4447{
533be4dd 4448 return (ep->type == bp_catchpoint);
c906108c
SS
4449}
4450
f431efe5
PA
4451/* Frees any storage that is part of a bpstat. Does not walk the
4452 'next' chain. */
4453
4454static void
198757a8
VP
4455bpstat_free (bpstat bs)
4456{
4457 if (bs->old_val != NULL)
4458 value_free (bs->old_val);
9add0f1b 4459 decref_counted_command_line (&bs->commands);
f431efe5 4460 decref_bp_location (&bs->bp_location_at);
198757a8
VP
4461 xfree (bs);
4462}
4463
c906108c
SS
4464/* Clear a bpstat so that it says we are not at any breakpoint.
4465 Also free any storage that is part of a bpstat. */
4466
4467void
fba45db2 4468bpstat_clear (bpstat *bsp)
c906108c
SS
4469{
4470 bpstat p;
4471 bpstat q;
4472
4473 if (bsp == 0)
4474 return;
4475 p = *bsp;
4476 while (p != NULL)
4477 {
4478 q = p->next;
198757a8 4479 bpstat_free (p);
c906108c
SS
4480 p = q;
4481 }
4482 *bsp = NULL;
4483}
4484
4485/* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4486 is part of the bpstat is copied as well. */
4487
4488bpstat
fba45db2 4489bpstat_copy (bpstat bs)
c906108c
SS
4490{
4491 bpstat p = NULL;
4492 bpstat tmp;
4493 bpstat retval = NULL;
4494
4495 if (bs == NULL)
4496 return bs;
4497
4498 for (; bs != NULL; bs = bs->next)
4499 {
4500 tmp = (bpstat) xmalloc (sizeof (*tmp));
4501 memcpy (tmp, bs, sizeof (*tmp));
9add0f1b 4502 incref_counted_command_line (tmp->commands);
f431efe5 4503 incref_bp_location (tmp->bp_location_at);
31cc81e9 4504 if (bs->old_val != NULL)
3c3185ac
JK
4505 {
4506 tmp->old_val = value_copy (bs->old_val);
4507 release_value (tmp->old_val);
4508 }
31cc81e9 4509
c906108c
SS
4510 if (p == NULL)
4511 /* This is the first thing in the chain. */
4512 retval = tmp;
4513 else
4514 p->next = tmp;
4515 p = tmp;
4516 }
4517 p->next = NULL;
4518 return retval;
4519}
4520
4a64f543 4521/* Find the bpstat associated with this breakpoint. */
c906108c
SS
4522
4523bpstat
fba45db2 4524bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
c906108c 4525{
c5aa993b
JM
4526 if (bsp == NULL)
4527 return NULL;
c906108c 4528
c5aa993b
JM
4529 for (; bsp != NULL; bsp = bsp->next)
4530 {
f431efe5 4531 if (bsp->breakpoint_at == breakpoint)
c5aa993b
JM
4532 return bsp;
4533 }
c906108c
SS
4534 return NULL;
4535}
4536
ab04a2af
TT
4537/* See breakpoint.h. */
4538
47591c29 4539int
427cd150 4540bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
ab04a2af 4541{
ab04a2af
TT
4542 for (; bsp != NULL; bsp = bsp->next)
4543 {
427cd150
TT
4544 if (bsp->breakpoint_at == NULL)
4545 {
4546 /* A moribund location can never explain a signal other than
4547 GDB_SIGNAL_TRAP. */
4548 if (sig == GDB_SIGNAL_TRAP)
47591c29 4549 return 1;
427cd150
TT
4550 }
4551 else
47591c29
PA
4552 {
4553 if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4554 sig))
4555 return 1;
4556 }
ab04a2af
TT
4557 }
4558
47591c29 4559 return 0;
ab04a2af
TT
4560}
4561
4a64f543
MS
4562/* Put in *NUM the breakpoint number of the first breakpoint we are
4563 stopped at. *BSP upon return is a bpstat which points to the
4564 remaining breakpoints stopped at (but which is not guaranteed to be
4565 good for anything but further calls to bpstat_num).
4566
8671a17b
PA
4567 Return 0 if passed a bpstat which does not indicate any breakpoints.
4568 Return -1 if stopped at a breakpoint that has been deleted since
4569 we set it.
4570 Return 1 otherwise. */
c906108c
SS
4571
4572int
8671a17b 4573bpstat_num (bpstat *bsp, int *num)
c906108c
SS
4574{
4575 struct breakpoint *b;
4576
4577 if ((*bsp) == NULL)
4578 return 0; /* No more breakpoint values */
8671a17b 4579
4a64f543
MS
4580 /* We assume we'll never have several bpstats that correspond to a
4581 single breakpoint -- otherwise, this function might return the
4582 same number more than once and this will look ugly. */
f431efe5 4583 b = (*bsp)->breakpoint_at;
8671a17b
PA
4584 *bsp = (*bsp)->next;
4585 if (b == NULL)
4586 return -1; /* breakpoint that's been deleted since */
4587
4588 *num = b->number; /* We have its number */
4589 return 1;
c906108c
SS
4590}
4591
e93ca019 4592/* See breakpoint.h. */
c906108c
SS
4593
4594void
e93ca019 4595bpstat_clear_actions (void)
c906108c 4596{
e93ca019
JK
4597 struct thread_info *tp;
4598 bpstat bs;
4599
4600 if (ptid_equal (inferior_ptid, null_ptid))
4601 return;
4602
4603 tp = find_thread_ptid (inferior_ptid);
4604 if (tp == NULL)
4605 return;
4606
4607 for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
c906108c 4608 {
9add0f1b 4609 decref_counted_command_line (&bs->commands);
abf85f46 4610
c906108c
SS
4611 if (bs->old_val != NULL)
4612 {
4613 value_free (bs->old_val);
4614 bs->old_val = NULL;
4615 }
4616 }
4617}
4618
f3b1572e
PA
4619/* Called when a command is about to proceed the inferior. */
4620
4621static void
4622breakpoint_about_to_proceed (void)
4623{
4624 if (!ptid_equal (inferior_ptid, null_ptid))
4625 {
4626 struct thread_info *tp = inferior_thread ();
4627
4628 /* Allow inferior function calls in breakpoint commands to not
4629 interrupt the command list. When the call finishes
4630 successfully, the inferior will be standing at the same
4631 breakpoint as if nothing happened. */
16c381f0 4632 if (tp->control.in_infcall)
f3b1572e
PA
4633 return;
4634 }
4635
4636 breakpoint_proceeded = 1;
4637}
4638
4a64f543
MS
4639/* Stub for cleaning up our state if we error-out of a breakpoint
4640 command. */
c906108c 4641static void
4efb68b1 4642cleanup_executing_breakpoints (void *ignore)
c906108c
SS
4643{
4644 executing_breakpoint_commands = 0;
4645}
4646
abf85f46
JK
4647/* Return non-zero iff CMD as the first line of a command sequence is `silent'
4648 or its equivalent. */
4649
4650static int
4651command_line_is_silent (struct command_line *cmd)
4652{
4f45d445 4653 return cmd && (strcmp ("silent", cmd->line) == 0);
abf85f46
JK
4654}
4655
4a64f543
MS
4656/* Execute all the commands associated with all the breakpoints at
4657 this location. Any of these commands could cause the process to
4658 proceed beyond this point, etc. We look out for such changes by
4659 checking the global "breakpoint_proceeded" after each command.
c906108c 4660
347bddb7
PA
4661 Returns true if a breakpoint command resumed the inferior. In that
4662 case, it is the caller's responsibility to recall it again with the
4663 bpstat of the current thread. */
4664
4665static int
4666bpstat_do_actions_1 (bpstat *bsp)
c906108c
SS
4667{
4668 bpstat bs;
4669 struct cleanup *old_chain;
347bddb7 4670 int again = 0;
c906108c
SS
4671
4672 /* Avoid endless recursion if a `source' command is contained
4673 in bs->commands. */
4674 if (executing_breakpoint_commands)
347bddb7 4675 return 0;
c906108c
SS
4676
4677 executing_breakpoint_commands = 1;
4678 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
4679
1ac32117 4680 scoped_restore preventer = prevent_dont_repeat ();
cf6c5ffb 4681
4a64f543 4682 /* This pointer will iterate over the list of bpstat's. */
c906108c
SS
4683 bs = *bsp;
4684
4685 breakpoint_proceeded = 0;
4686 for (; bs != NULL; bs = bs->next)
4687 {
9add0f1b 4688 struct counted_command_line *ccmd;
6c50ab1c
JB
4689 struct command_line *cmd;
4690 struct cleanup *this_cmd_tree_chain;
4691
4692 /* Take ownership of the BSP's command tree, if it has one.
4693
4694 The command tree could legitimately contain commands like
4695 'step' and 'next', which call clear_proceed_status, which
4696 frees stop_bpstat's command tree. To make sure this doesn't
4697 free the tree we're executing out from under us, we need to
4698 take ownership of the tree ourselves. Since a given bpstat's
4699 commands are only executed once, we don't need to copy it; we
4700 can clear the pointer in the bpstat, and make sure we free
4701 the tree when we're done. */
9add0f1b
TT
4702 ccmd = bs->commands;
4703 bs->commands = NULL;
abf85f46
JK
4704 this_cmd_tree_chain = make_cleanup_decref_counted_command_line (&ccmd);
4705 cmd = ccmd ? ccmd->commands : NULL;
4706 if (command_line_is_silent (cmd))
4707 {
4708 /* The action has been already done by bpstat_stop_status. */
4709 cmd = cmd->next;
4710 }
6c50ab1c 4711
c906108c
SS
4712 while (cmd != NULL)
4713 {
4714 execute_control_command (cmd);
4715
4716 if (breakpoint_proceeded)
4717 break;
4718 else
4719 cmd = cmd->next;
4720 }
6c50ab1c
JB
4721
4722 /* We can free this command tree now. */
4723 do_cleanups (this_cmd_tree_chain);
4724
c906108c 4725 if (breakpoint_proceeded)
32c1e744 4726 {
cb814510 4727 if (current_ui->async)
347bddb7
PA
4728 /* If we are in async mode, then the target might be still
4729 running, not stopped at any breakpoint, so nothing for
4730 us to do here -- just return to the event loop. */
4731 ;
32c1e744
VP
4732 else
4733 /* In sync mode, when execute_control_command returns
4734 we're already standing on the next breakpoint.
347bddb7
PA
4735 Breakpoint commands for that stop were not run, since
4736 execute_command does not run breakpoint commands --
4737 only command_line_handler does, but that one is not
4738 involved in execution of breakpoint commands. So, we
4739 can now execute breakpoint commands. It should be
4740 noted that making execute_command do bpstat actions is
4741 not an option -- in this case we'll have recursive
4742 invocation of bpstat for each breakpoint with a
4743 command, and can easily blow up GDB stack. Instead, we
4744 return true, which will trigger the caller to recall us
4745 with the new stop_bpstat. */
4746 again = 1;
4747 break;
32c1e744 4748 }
c906108c 4749 }
c2b8ed2c 4750 do_cleanups (old_chain);
347bddb7
PA
4751 return again;
4752}
4753
4754void
4755bpstat_do_actions (void)
4756{
353d1d73
JK
4757 struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4758
347bddb7
PA
4759 /* Do any commands attached to breakpoint we are stopped at. */
4760 while (!ptid_equal (inferior_ptid, null_ptid)
4761 && target_has_execution
4762 && !is_exited (inferior_ptid)
4763 && !is_executing (inferior_ptid))
4764 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4765 and only return when it is stopped at the next breakpoint, we
4766 keep doing breakpoint actions until it returns false to
4767 indicate the inferior was not resumed. */
16c381f0 4768 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
347bddb7 4769 break;
353d1d73
JK
4770
4771 discard_cleanups (cleanup_if_error);
c906108c
SS
4772}
4773
fa4727a6
DJ
4774/* Print out the (old or new) value associated with a watchpoint. */
4775
4776static void
4777watchpoint_value_print (struct value *val, struct ui_file *stream)
4778{
4779 if (val == NULL)
4780 fprintf_unfiltered (stream, _("<unreadable>"));
4781 else
79a45b7d
TT
4782 {
4783 struct value_print_options opts;
4784 get_user_print_options (&opts);
4785 value_print (val, stream, &opts);
4786 }
fa4727a6
DJ
4787}
4788
f303dbd6
PA
4789/* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4790 debugging multiple threads. */
4791
4792void
4793maybe_print_thread_hit_breakpoint (struct ui_out *uiout)
4794{
112e8700 4795 if (uiout->is_mi_like_p ())
f303dbd6
PA
4796 return;
4797
112e8700 4798 uiout->text ("\n");
f303dbd6
PA
4799
4800 if (show_thread_that_caused_stop ())
4801 {
4802 const char *name;
4803 struct thread_info *thr = inferior_thread ();
4804
112e8700
SM
4805 uiout->text ("Thread ");
4806 uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
f303dbd6
PA
4807
4808 name = thr->name != NULL ? thr->name : target_thread_name (thr);
4809 if (name != NULL)
4810 {
112e8700
SM
4811 uiout->text (" \"");
4812 uiout->field_fmt ("name", "%s", name);
4813 uiout->text ("\"");
f303dbd6
PA
4814 }
4815
112e8700 4816 uiout->text (" hit ");
f303dbd6
PA
4817 }
4818}
4819
e514a9d6 4820/* Generic routine for printing messages indicating why we
4a64f543 4821 stopped. The behavior of this function depends on the value
e514a9d6
JM
4822 'print_it' in the bpstat structure. Under some circumstances we
4823 may decide not to print anything here and delegate the task to
4a64f543 4824 normal_stop(). */
e514a9d6
JM
4825
4826static enum print_stop_action
4827print_bp_stop_message (bpstat bs)
4828{
4829 switch (bs->print_it)
4830 {
4831 case print_it_noop:
4a64f543 4832 /* Nothing should be printed for this bpstat entry. */
e514a9d6
JM
4833 return PRINT_UNKNOWN;
4834 break;
4835
4836 case print_it_done:
4837 /* We still want to print the frame, but we already printed the
4a64f543 4838 relevant messages. */
e514a9d6
JM
4839 return PRINT_SRC_AND_LOC;
4840 break;
4841
4842 case print_it_normal:
4f8d1dc6 4843 {
f431efe5
PA
4844 struct breakpoint *b = bs->breakpoint_at;
4845
1a6a67de
TJB
4846 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4847 which has since been deleted. */
4848 if (b == NULL)
4849 return PRINT_UNKNOWN;
4850
348d480f
PA
4851 /* Normal case. Call the breakpoint's print_it method. */
4852 return b->ops->print_it (bs);
4f8d1dc6 4853 }
348d480f 4854 break;
3086aeae 4855
e514a9d6 4856 default:
8e65ff28 4857 internal_error (__FILE__, __LINE__,
e2e0b3e5 4858 _("print_bp_stop_message: unrecognized enum value"));
e514a9d6 4859 break;
c906108c 4860 }
c906108c
SS
4861}
4862
edcc5120
TT
4863/* A helper function that prints a shared library stopped event. */
4864
4865static void
4866print_solib_event (int is_catchpoint)
4867{
4868 int any_deleted
4869 = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
4870 int any_added
4871 = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
4872
4873 if (!is_catchpoint)
4874 {
4875 if (any_added || any_deleted)
112e8700 4876 current_uiout->text (_("Stopped due to shared library event:\n"));
edcc5120 4877 else
112e8700
SM
4878 current_uiout->text (_("Stopped due to shared library event (no "
4879 "libraries added or removed)\n"));
edcc5120
TT
4880 }
4881
112e8700
SM
4882 if (current_uiout->is_mi_like_p ())
4883 current_uiout->field_string ("reason",
4884 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
edcc5120
TT
4885
4886 if (any_deleted)
4887 {
4888 struct cleanup *cleanup;
4889 char *name;
4890 int ix;
4891
112e8700 4892 current_uiout->text (_(" Inferior unloaded "));
edcc5120
TT
4893 cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4894 "removed");
4895 for (ix = 0;
4896 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
4897 ix, name);
4898 ++ix)
4899 {
4900 if (ix > 0)
112e8700
SM
4901 current_uiout->text (" ");
4902 current_uiout->field_string ("library", name);
4903 current_uiout->text ("\n");
edcc5120
TT
4904 }
4905
4906 do_cleanups (cleanup);
4907 }
4908
4909 if (any_added)
4910 {
4911 struct so_list *iter;
4912 int ix;
4913 struct cleanup *cleanup;
4914
112e8700 4915 current_uiout->text (_(" Inferior loaded "));
edcc5120
TT
4916 cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4917 "added");
4918 for (ix = 0;
4919 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
4920 ix, iter);
4921 ++ix)
4922 {
4923 if (ix > 0)
112e8700
SM
4924 current_uiout->text (" ");
4925 current_uiout->field_string ("library", iter->so_name);
4926 current_uiout->text ("\n");
edcc5120
TT
4927 }
4928
4929 do_cleanups (cleanup);
4930 }
4931}
4932
e514a9d6
JM
4933/* Print a message indicating what happened. This is called from
4934 normal_stop(). The input to this routine is the head of the bpstat
36dfb11c
TT
4935 list - a list of the eventpoints that caused this stop. KIND is
4936 the target_waitkind for the stopping event. This
e514a9d6
JM
4937 routine calls the generic print routine for printing a message
4938 about reasons for stopping. This will print (for example) the
4939 "Breakpoint n," part of the output. The return value of this
4940 routine is one of:
c906108c 4941
4a64f543 4942 PRINT_UNKNOWN: Means we printed nothing.
917317f4 4943 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4a64f543 4944 code to print the location. An example is
c5aa993b
JM
4945 "Breakpoint 1, " which should be followed by
4946 the location.
917317f4 4947 PRINT_SRC_ONLY: Means we printed something, but there is no need
c5aa993b
JM
4948 to also print the location part of the message.
4949 An example is the catch/throw messages, which
4a64f543 4950 don't require a location appended to the end.
917317f4 4951 PRINT_NOTHING: We have done some printing and we don't need any
4a64f543 4952 further info to be printed. */
c906108c 4953
917317f4 4954enum print_stop_action
36dfb11c 4955bpstat_print (bpstat bs, int kind)
c906108c 4956{
f486487f 4957 enum print_stop_action val;
c5aa993b 4958
c906108c 4959 /* Maybe another breakpoint in the chain caused us to stop.
53a5351d
JM
4960 (Currently all watchpoints go on the bpstat whether hit or not.
4961 That probably could (should) be changed, provided care is taken
c906108c 4962 with respect to bpstat_explains_signal). */
e514a9d6
JM
4963 for (; bs; bs = bs->next)
4964 {
4965 val = print_bp_stop_message (bs);
4966 if (val == PRINT_SRC_ONLY
4967 || val == PRINT_SRC_AND_LOC
4968 || val == PRINT_NOTHING)
4969 return val;
4970 }
c906108c 4971
36dfb11c
TT
4972 /* If we had hit a shared library event breakpoint,
4973 print_bp_stop_message would print out this message. If we hit an
4974 OS-level shared library event, do the same thing. */
4975 if (kind == TARGET_WAITKIND_LOADED)
4976 {
edcc5120 4977 print_solib_event (0);
36dfb11c
TT
4978 return PRINT_NOTHING;
4979 }
4980
e514a9d6 4981 /* We reached the end of the chain, or we got a null BS to start
4a64f543 4982 with and nothing was printed. */
917317f4 4983 return PRINT_UNKNOWN;
c906108c
SS
4984}
4985
c42bd95a
DE
4986/* Evaluate the expression EXP and return 1 if value is zero.
4987 This returns the inverse of the condition because it is called
4988 from catch_errors which returns 0 if an exception happened, and if an
4989 exception happens we want execution to stop.
4a64f543 4990 The argument is a "struct expression *" that has been cast to a
c42bd95a 4991 "void *" to make it pass through catch_errors. */
c906108c
SS
4992
4993static int
4efb68b1 4994breakpoint_cond_eval (void *exp)
c906108c 4995{
278cd55f 4996 struct value *mark = value_mark ();
c5aa993b 4997 int i = !value_true (evaluate_expression ((struct expression *) exp));
cc59ec59 4998
c906108c
SS
4999 value_free_to_mark (mark);
5000 return i;
5001}
5002
5760d0ab 5003/* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
c906108c
SS
5004
5005static bpstat
5760d0ab 5006bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
c906108c
SS
5007{
5008 bpstat bs;
5009
5010 bs = (bpstat) xmalloc (sizeof (*bs));
5760d0ab
JK
5011 bs->next = NULL;
5012 **bs_link_pointer = bs;
5013 *bs_link_pointer = &bs->next;
f431efe5
PA
5014 bs->breakpoint_at = bl->owner;
5015 bs->bp_location_at = bl;
5016 incref_bp_location (bl);
c906108c
SS
5017 /* If the condition is false, etc., don't do the commands. */
5018 bs->commands = NULL;
5019 bs->old_val = NULL;
5020 bs->print_it = print_it_normal;
5021 return bs;
5022}
5023\f
d983da9c
DJ
5024/* The target has stopped with waitstatus WS. Check if any hardware
5025 watchpoints have triggered, according to the target. */
5026
5027int
5028watchpoints_triggered (struct target_waitstatus *ws)
5029{
d92524f1 5030 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
d983da9c
DJ
5031 CORE_ADDR addr;
5032 struct breakpoint *b;
5033
5034 if (!stopped_by_watchpoint)
5035 {
5036 /* We were not stopped by a watchpoint. Mark all watchpoints
5037 as not triggered. */
5038 ALL_BREAKPOINTS (b)
cc60f2e3 5039 if (is_hardware_watchpoint (b))
3a5c3e22
PA
5040 {
5041 struct watchpoint *w = (struct watchpoint *) b;
5042
5043 w->watchpoint_triggered = watch_triggered_no;
5044 }
d983da9c
DJ
5045
5046 return 0;
5047 }
5048
5049 if (!target_stopped_data_address (&current_target, &addr))
5050 {
5051 /* We were stopped by a watchpoint, but we don't know where.
5052 Mark all watchpoints as unknown. */
5053 ALL_BREAKPOINTS (b)
cc60f2e3 5054 if (is_hardware_watchpoint (b))
3a5c3e22
PA
5055 {
5056 struct watchpoint *w = (struct watchpoint *) b;
5057
5058 w->watchpoint_triggered = watch_triggered_unknown;
5059 }
d983da9c 5060
3c4797ba 5061 return 1;
d983da9c
DJ
5062 }
5063
5064 /* The target could report the data address. Mark watchpoints
5065 affected by this data address as triggered, and all others as not
5066 triggered. */
5067
5068 ALL_BREAKPOINTS (b)
cc60f2e3 5069 if (is_hardware_watchpoint (b))
d983da9c 5070 {
3a5c3e22 5071 struct watchpoint *w = (struct watchpoint *) b;
a5606eee 5072 struct bp_location *loc;
d983da9c 5073
3a5c3e22 5074 w->watchpoint_triggered = watch_triggered_no;
a5606eee 5075 for (loc = b->loc; loc; loc = loc->next)
9c06b0b4 5076 {
3a5c3e22 5077 if (is_masked_watchpoint (b))
9c06b0b4 5078 {
3a5c3e22
PA
5079 CORE_ADDR newaddr = addr & w->hw_wp_mask;
5080 CORE_ADDR start = loc->address & w->hw_wp_mask;
9c06b0b4
TJB
5081
5082 if (newaddr == start)
5083 {
3a5c3e22 5084 w->watchpoint_triggered = watch_triggered_yes;
9c06b0b4
TJB
5085 break;
5086 }
5087 }
5088 /* Exact match not required. Within range is sufficient. */
5089 else if (target_watchpoint_addr_within_range (&current_target,
5090 addr, loc->address,
5091 loc->length))
5092 {
3a5c3e22 5093 w->watchpoint_triggered = watch_triggered_yes;
9c06b0b4
TJB
5094 break;
5095 }
5096 }
d983da9c
DJ
5097 }
5098
5099 return 1;
5100}
5101
c906108c
SS
5102/* Possible return values for watchpoint_check (this can't be an enum
5103 because of check_errors). */
5104/* The watchpoint has been deleted. */
5105#define WP_DELETED 1
5106/* The value has changed. */
5107#define WP_VALUE_CHANGED 2
5108/* The value has not changed. */
5109#define WP_VALUE_NOT_CHANGED 3
60e1c644
PA
5110/* Ignore this watchpoint, no matter if the value changed or not. */
5111#define WP_IGNORE 4
c906108c
SS
5112
5113#define BP_TEMPFLAG 1
5114#define BP_HARDWAREFLAG 2
5115
4a64f543
MS
5116/* Evaluate watchpoint condition expression and check if its value
5117 changed.
553e4c11
JB
5118
5119 P should be a pointer to struct bpstat, but is defined as a void *
5120 in order for this function to be usable with catch_errors. */
c906108c
SS
5121
5122static int
4efb68b1 5123watchpoint_check (void *p)
c906108c
SS
5124{
5125 bpstat bs = (bpstat) p;
3a5c3e22 5126 struct watchpoint *b;
c906108c
SS
5127 struct frame_info *fr;
5128 int within_current_scope;
5129
f431efe5 5130 /* BS is built from an existing struct breakpoint. */
2bdf28a0 5131 gdb_assert (bs->breakpoint_at != NULL);
3a5c3e22 5132 b = (struct watchpoint *) bs->breakpoint_at;
d0fb5eae 5133
f6bc2008
PA
5134 /* If this is a local watchpoint, we only want to check if the
5135 watchpoint frame is in scope if the current thread is the thread
5136 that was used to create the watchpoint. */
5137 if (!watchpoint_in_thread_scope (b))
60e1c644 5138 return WP_IGNORE;
f6bc2008 5139
c906108c
SS
5140 if (b->exp_valid_block == NULL)
5141 within_current_scope = 1;
5142 else
5143 {
edb3359d
DJ
5144 struct frame_info *frame = get_current_frame ();
5145 struct gdbarch *frame_arch = get_frame_arch (frame);
5146 CORE_ADDR frame_pc = get_frame_pc (frame);
5147
c9cf6e20 5148 /* stack_frame_destroyed_p() returns a non-zero value if we're
4a64f543
MS
5149 still in the function but the stack frame has already been
5150 invalidated. Since we can't rely on the values of local
5151 variables after the stack has been destroyed, we are treating
5152 the watchpoint in that state as `not changed' without further
5153 checking. Don't mark watchpoints as changed if the current
5154 frame is in an epilogue - even if they are in some other
5155 frame, our view of the stack is likely to be wrong and
5156 frame_find_by_id could error out. */
c9cf6e20 5157 if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
60e1c644 5158 return WP_IGNORE;
a0f49112 5159
101dcfbe 5160 fr = frame_find_by_id (b->watchpoint_frame);
c906108c 5161 within_current_scope = (fr != NULL);
69fbadd5
DJ
5162
5163 /* If we've gotten confused in the unwinder, we might have
5164 returned a frame that can't describe this variable. */
edb3359d
DJ
5165 if (within_current_scope)
5166 {
5167 struct symbol *function;
5168
5169 function = get_frame_function (fr);
5170 if (function == NULL
5171 || !contained_in (b->exp_valid_block,
5172 SYMBOL_BLOCK_VALUE (function)))
5173 within_current_scope = 0;
5174 }
69fbadd5 5175
edb3359d 5176 if (within_current_scope)
c906108c
SS
5177 /* If we end up stopping, the current frame will get selected
5178 in normal_stop. So this call to select_frame won't affect
5179 the user. */
0f7d239c 5180 select_frame (fr);
c906108c 5181 }
c5aa993b 5182
c906108c
SS
5183 if (within_current_scope)
5184 {
4a64f543
MS
5185 /* We use value_{,free_to_}mark because it could be a *long*
5186 time before we return to the command level and call
5187 free_all_values. We can't call free_all_values because we
5188 might be in the middle of evaluating a function call. */
c906108c 5189
0cf6dd15 5190 int pc = 0;
9c06b0b4 5191 struct value *mark;
fa4727a6
DJ
5192 struct value *new_val;
5193
3a5c3e22 5194 if (is_masked_watchpoint (&b->base))
9c06b0b4
TJB
5195 /* Since we don't know the exact trigger address (from
5196 stopped_data_address), just tell the user we've triggered
5197 a mask watchpoint. */
5198 return WP_VALUE_CHANGED;
5199
5200 mark = value_mark ();
4d01a485 5201 fetch_subexp_value (b->exp.get (), &pc, &new_val, NULL, NULL, 0);
218d2fc6 5202
bb9d5f81
PP
5203 if (b->val_bitsize != 0)
5204 new_val = extract_bitfield_from_watchpoint_value (b, new_val);
5205
4a64f543
MS
5206 /* We use value_equal_contents instead of value_equal because
5207 the latter coerces an array to a pointer, thus comparing just
5208 the address of the array instead of its contents. This is
5209 not what we want. */
fa4727a6 5210 if ((b->val != NULL) != (new_val != NULL)
218d2fc6 5211 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
c906108c 5212 {
fa4727a6
DJ
5213 if (new_val != NULL)
5214 {
5215 release_value (new_val);
5216 value_free_to_mark (mark);
5217 }
c906108c
SS
5218 bs->old_val = b->val;
5219 b->val = new_val;
fa4727a6 5220 b->val_valid = 1;
c906108c
SS
5221 return WP_VALUE_CHANGED;
5222 }
5223 else
5224 {
60e1c644 5225 /* Nothing changed. */
c906108c 5226 value_free_to_mark (mark);
c906108c
SS
5227 return WP_VALUE_NOT_CHANGED;
5228 }
5229 }
5230 else
5231 {
5232 /* This seems like the only logical thing to do because
c5aa993b
JM
5233 if we temporarily ignored the watchpoint, then when
5234 we reenter the block in which it is valid it contains
5235 garbage (in the case of a function, it may have two
5236 garbage values, one before and one after the prologue).
5237 So we can't even detect the first assignment to it and
5238 watch after that (since the garbage may or may not equal
5239 the first value assigned). */
348d480f
PA
5240 /* We print all the stop information in
5241 breakpoint_ops->print_it, but in this case, by the time we
5242 call breakpoint_ops->print_it this bp will be deleted
5243 already. So we have no choice but print the information
5244 here. */
468afe6c 5245
0e454242 5246 SWITCH_THRU_ALL_UIS ()
468afe6c
PA
5247 {
5248 struct ui_out *uiout = current_uiout;
5249
112e8700
SM
5250 if (uiout->is_mi_like_p ())
5251 uiout->field_string
5252 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
5253 uiout->text ("\nWatchpoint ");
5254 uiout->field_int ("wpnum", b->base.number);
5255 uiout->text (" deleted because the program has left the block in\n"
468afe6c
PA
5256 "which its expression is valid.\n");
5257 }
4ce44c66 5258
cdac0397 5259 /* Make sure the watchpoint's commands aren't executed. */
3a5c3e22 5260 decref_counted_command_line (&b->base.commands);
d0fb5eae 5261 watchpoint_del_at_next_stop (b);
c906108c
SS
5262
5263 return WP_DELETED;
5264 }
5265}
5266
18a18393 5267/* Return true if it looks like target has stopped due to hitting
348d480f
PA
5268 breakpoint location BL. This function does not check if we should
5269 stop, only if BL explains the stop. */
5270
18a18393 5271static int
6c95b8df 5272bpstat_check_location (const struct bp_location *bl,
09ac7c10
TT
5273 struct address_space *aspace, CORE_ADDR bp_addr,
5274 const struct target_waitstatus *ws)
18a18393
VP
5275{
5276 struct breakpoint *b = bl->owner;
5277
348d480f 5278 /* BL is from an existing breakpoint. */
2bdf28a0
JK
5279 gdb_assert (b != NULL);
5280
09ac7c10 5281 return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
18a18393
VP
5282}
5283
3a5c3e22
PA
5284/* Determine if the watched values have actually changed, and we
5285 should stop. If not, set BS->stop to 0. */
5286
18a18393
VP
5287static void
5288bpstat_check_watchpoint (bpstat bs)
5289{
2bdf28a0 5290 const struct bp_location *bl;
3a5c3e22 5291 struct watchpoint *b;
2bdf28a0
JK
5292
5293 /* BS is built for existing struct breakpoint. */
f431efe5 5294 bl = bs->bp_location_at;
2bdf28a0 5295 gdb_assert (bl != NULL);
3a5c3e22 5296 b = (struct watchpoint *) bs->breakpoint_at;
2bdf28a0 5297 gdb_assert (b != NULL);
18a18393 5298
18a18393 5299 {
18a18393
VP
5300 int must_check_value = 0;
5301
3a5c3e22 5302 if (b->base.type == bp_watchpoint)
18a18393
VP
5303 /* For a software watchpoint, we must always check the
5304 watched value. */
5305 must_check_value = 1;
5306 else if (b->watchpoint_triggered == watch_triggered_yes)
5307 /* We have a hardware watchpoint (read, write, or access)
5308 and the target earlier reported an address watched by
5309 this watchpoint. */
5310 must_check_value = 1;
5311 else if (b->watchpoint_triggered == watch_triggered_unknown
3a5c3e22 5312 && b->base.type == bp_hardware_watchpoint)
18a18393
VP
5313 /* We were stopped by a hardware watchpoint, but the target could
5314 not report the data address. We must check the watchpoint's
5315 value. Access and read watchpoints are out of luck; without
5316 a data address, we can't figure it out. */
5317 must_check_value = 1;
3a5c3e22 5318
18a18393
VP
5319 if (must_check_value)
5320 {
3e43a32a
MS
5321 char *message
5322 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3a5c3e22 5323 b->base.number);
18a18393
VP
5324 struct cleanup *cleanups = make_cleanup (xfree, message);
5325 int e = catch_errors (watchpoint_check, bs, message,
5326 RETURN_MASK_ALL);
5327 do_cleanups (cleanups);
5328 switch (e)
5329 {
5330 case WP_DELETED:
5331 /* We've already printed what needs to be printed. */
5332 bs->print_it = print_it_done;
5333 /* Stop. */
5334 break;
60e1c644
PA
5335 case WP_IGNORE:
5336 bs->print_it = print_it_noop;
5337 bs->stop = 0;
5338 break;
18a18393 5339 case WP_VALUE_CHANGED:
3a5c3e22 5340 if (b->base.type == bp_read_watchpoint)
18a18393 5341 {
85d721b8
PA
5342 /* There are two cases to consider here:
5343
4a64f543 5344 1. We're watching the triggered memory for reads.
85d721b8
PA
5345 In that case, trust the target, and always report
5346 the watchpoint hit to the user. Even though
5347 reads don't cause value changes, the value may
5348 have changed since the last time it was read, and
5349 since we're not trapping writes, we will not see
5350 those, and as such we should ignore our notion of
5351 old value.
5352
4a64f543 5353 2. We're watching the triggered memory for both
85d721b8
PA
5354 reads and writes. There are two ways this may
5355 happen:
5356
4a64f543 5357 2.1. This is a target that can't break on data
85d721b8
PA
5358 reads only, but can break on accesses (reads or
5359 writes), such as e.g., x86. We detect this case
5360 at the time we try to insert read watchpoints.
5361
4a64f543 5362 2.2. Otherwise, the target supports read
85d721b8
PA
5363 watchpoints, but, the user set an access or write
5364 watchpoint watching the same memory as this read
5365 watchpoint.
5366
5367 If we're watching memory writes as well as reads,
5368 ignore watchpoint hits when we find that the
5369 value hasn't changed, as reads don't cause
5370 changes. This still gives false positives when
5371 the program writes the same value to memory as
5372 what there was already in memory (we will confuse
5373 it for a read), but it's much better than
5374 nothing. */
5375
5376 int other_write_watchpoint = 0;
5377
5378 if (bl->watchpoint_type == hw_read)
5379 {
5380 struct breakpoint *other_b;
5381
5382 ALL_BREAKPOINTS (other_b)
3a5c3e22
PA
5383 if (other_b->type == bp_hardware_watchpoint
5384 || other_b->type == bp_access_watchpoint)
85d721b8 5385 {
3a5c3e22
PA
5386 struct watchpoint *other_w =
5387 (struct watchpoint *) other_b;
5388
5389 if (other_w->watchpoint_triggered
5390 == watch_triggered_yes)
5391 {
5392 other_write_watchpoint = 1;
5393 break;
5394 }
85d721b8
PA
5395 }
5396 }
5397
5398 if (other_write_watchpoint
5399 || bl->watchpoint_type == hw_access)
5400 {
5401 /* We're watching the same memory for writes,
5402 and the value changed since the last time we
5403 updated it, so this trap must be for a write.
5404 Ignore it. */
5405 bs->print_it = print_it_noop;
5406 bs->stop = 0;
5407 }
18a18393
VP
5408 }
5409 break;
5410 case WP_VALUE_NOT_CHANGED:
3a5c3e22
PA
5411 if (b->base.type == bp_hardware_watchpoint
5412 || b->base.type == bp_watchpoint)
18a18393
VP
5413 {
5414 /* Don't stop: write watchpoints shouldn't fire if
5415 the value hasn't changed. */
5416 bs->print_it = print_it_noop;
5417 bs->stop = 0;
5418 }
5419 /* Stop. */
5420 break;
5421 default:
5422 /* Can't happen. */
5423 case 0:
5424 /* Error from catch_errors. */
468afe6c 5425 {
0e454242 5426 SWITCH_THRU_ALL_UIS ()
468afe6c
PA
5427 {
5428 printf_filtered (_("Watchpoint %d deleted.\n"),
5429 b->base.number);
5430 }
5431 watchpoint_del_at_next_stop (b);
5432 /* We've already printed what needs to be printed. */
5433 bs->print_it = print_it_done;
5434 }
18a18393
VP
5435 break;
5436 }
5437 }
5438 else /* must_check_value == 0 */
5439 {
5440 /* This is a case where some watchpoint(s) triggered, but
5441 not at the address of this watchpoint, or else no
5442 watchpoint triggered after all. So don't print
5443 anything for this watchpoint. */
5444 bs->print_it = print_it_noop;
5445 bs->stop = 0;
5446 }
5447 }
5448}
5449
7d4df6a4
DE
5450/* For breakpoints that are currently marked as telling gdb to stop,
5451 check conditions (condition proper, frame, thread and ignore count)
18a18393
VP
5452 of breakpoint referred to by BS. If we should not stop for this
5453 breakpoint, set BS->stop to 0. */
f431efe5 5454
18a18393
VP
5455static void
5456bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
5457{
2bdf28a0
JK
5458 const struct bp_location *bl;
5459 struct breakpoint *b;
7d4df6a4
DE
5460 int value_is_zero = 0;
5461 struct expression *cond;
5462
5463 gdb_assert (bs->stop);
2bdf28a0
JK
5464
5465 /* BS is built for existing struct breakpoint. */
f431efe5 5466 bl = bs->bp_location_at;
2bdf28a0 5467 gdb_assert (bl != NULL);
f431efe5 5468 b = bs->breakpoint_at;
2bdf28a0 5469 gdb_assert (b != NULL);
18a18393 5470
b775012e
LM
5471 /* Even if the target evaluated the condition on its end and notified GDB, we
5472 need to do so again since GDB does not know if we stopped due to a
5473 breakpoint or a single step breakpoint. */
5474
18a18393 5475 if (frame_id_p (b->frame_id)
edb3359d 5476 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
18a18393 5477 {
7d4df6a4
DE
5478 bs->stop = 0;
5479 return;
5480 }
60e1c644 5481
12ab52e9
PA
5482 /* If this is a thread/task-specific breakpoint, don't waste cpu
5483 evaluating the condition if this isn't the specified
5484 thread/task. */
5d5658a1 5485 if ((b->thread != -1 && b->thread != ptid_to_global_thread_id (ptid))
12ab52e9
PA
5486 || (b->task != 0 && b->task != ada_get_task_number (ptid)))
5487
6c1b0f7b
DE
5488 {
5489 bs->stop = 0;
5490 return;
5491 }
5492
6dddc817
DE
5493 /* Evaluate extension language breakpoints that have a "stop" method
5494 implemented. */
5495 bs->stop = breakpoint_ext_lang_cond_says_stop (b);
7371cf6d 5496
7d4df6a4
DE
5497 if (is_watchpoint (b))
5498 {
5499 struct watchpoint *w = (struct watchpoint *) b;
3a5c3e22 5500
4d01a485 5501 cond = w->cond_exp.get ();
7d4df6a4
DE
5502 }
5503 else
4d01a485 5504 cond = bl->cond.get ();
60e1c644 5505
7d4df6a4
DE
5506 if (cond && b->disposition != disp_del_at_next_stop)
5507 {
5508 int within_current_scope = 1;
5509 struct watchpoint * w;
60e1c644 5510
7d4df6a4
DE
5511 /* We use value_mark and value_free_to_mark because it could
5512 be a long time before we return to the command level and
5513 call free_all_values. We can't call free_all_values
5514 because we might be in the middle of evaluating a
5515 function call. */
5516 struct value *mark = value_mark ();
5517
5518 if (is_watchpoint (b))
5519 w = (struct watchpoint *) b;
5520 else
5521 w = NULL;
5522
5523 /* Need to select the frame, with all that implies so that
5524 the conditions will have the right context. Because we
5525 use the frame, we will not see an inlined function's
5526 variables when we arrive at a breakpoint at the start
5527 of the inlined function; the current frame will be the
5528 call site. */
5529 if (w == NULL || w->cond_exp_valid_block == NULL)
5530 select_frame (get_current_frame ());
5531 else
18a18393 5532 {
7d4df6a4
DE
5533 struct frame_info *frame;
5534
5535 /* For local watchpoint expressions, which particular
5536 instance of a local is being watched matters, so we
5537 keep track of the frame to evaluate the expression
5538 in. To evaluate the condition however, it doesn't
5539 really matter which instantiation of the function
5540 where the condition makes sense triggers the
5541 watchpoint. This allows an expression like "watch
5542 global if q > 10" set in `func', catch writes to
5543 global on all threads that call `func', or catch
5544 writes on all recursive calls of `func' by a single
5545 thread. We simply always evaluate the condition in
5546 the innermost frame that's executing where it makes
5547 sense to evaluate the condition. It seems
5548 intuitive. */
5549 frame = block_innermost_frame (w->cond_exp_valid_block);
5550 if (frame != NULL)
5551 select_frame (frame);
5552 else
5553 within_current_scope = 0;
18a18393 5554 }
7d4df6a4
DE
5555 if (within_current_scope)
5556 value_is_zero
5557 = catch_errors (breakpoint_cond_eval, cond,
5558 "Error in testing breakpoint condition:\n",
5559 RETURN_MASK_ALL);
5560 else
18a18393 5561 {
7d4df6a4
DE
5562 warning (_("Watchpoint condition cannot be tested "
5563 "in the current scope"));
5564 /* If we failed to set the right context for this
5565 watchpoint, unconditionally report it. */
5566 value_is_zero = 0;
18a18393 5567 }
7d4df6a4
DE
5568 /* FIXME-someday, should give breakpoint #. */
5569 value_free_to_mark (mark);
18a18393 5570 }
7d4df6a4
DE
5571
5572 if (cond && value_is_zero)
5573 {
5574 bs->stop = 0;
5575 }
7d4df6a4
DE
5576 else if (b->ignore_count > 0)
5577 {
5578 b->ignore_count--;
5579 bs->stop = 0;
5580 /* Increase the hit count even though we don't stop. */
5581 ++(b->hit_count);
5582 observer_notify_breakpoint_modified (b);
5583 }
18a18393
VP
5584}
5585
1cf4d951
PA
5586/* Returns true if we need to track moribund locations of LOC's type
5587 on the current target. */
5588
5589static int
5590need_moribund_for_location_type (struct bp_location *loc)
5591{
5592 return ((loc->loc_type == bp_loc_software_breakpoint
5593 && !target_supports_stopped_by_sw_breakpoint ())
5594 || (loc->loc_type == bp_loc_hardware_breakpoint
5595 && !target_supports_stopped_by_hw_breakpoint ()));
5596}
5597
18a18393 5598
9709f61c 5599/* Get a bpstat associated with having just stopped at address
d983da9c 5600 BP_ADDR in thread PTID.
c906108c 5601
d983da9c 5602 Determine whether we stopped at a breakpoint, etc, or whether we
4a64f543
MS
5603 don't understand this stop. Result is a chain of bpstat's such
5604 that:
c906108c 5605
c5aa993b 5606 if we don't understand the stop, the result is a null pointer.
c906108c 5607
c5aa993b 5608 if we understand why we stopped, the result is not null.
c906108c 5609
c5aa993b
JM
5610 Each element of the chain refers to a particular breakpoint or
5611 watchpoint at which we have stopped. (We may have stopped for
5612 several reasons concurrently.)
c906108c 5613
c5aa993b
JM
5614 Each element of the chain has valid next, breakpoint_at,
5615 commands, FIXME??? fields. */
c906108c
SS
5616
5617bpstat
6c95b8df 5618bpstat_stop_status (struct address_space *aspace,
09ac7c10
TT
5619 CORE_ADDR bp_addr, ptid_t ptid,
5620 const struct target_waitstatus *ws)
c906108c 5621{
0d381245 5622 struct breakpoint *b = NULL;
afe38095 5623 struct bp_location *bl;
20874c92 5624 struct bp_location *loc;
5760d0ab
JK
5625 /* First item of allocated bpstat's. */
5626 bpstat bs_head = NULL, *bs_link = &bs_head;
c906108c 5627 /* Pointer to the last thing in the chain currently. */
5760d0ab 5628 bpstat bs;
20874c92 5629 int ix;
429374b8 5630 int need_remove_insert;
f431efe5 5631 int removed_any;
c906108c 5632
f431efe5
PA
5633 /* First, build the bpstat chain with locations that explain a
5634 target stop, while being careful to not set the target running,
5635 as that may invalidate locations (in particular watchpoint
5636 locations are recreated). Resuming will happen here with
5637 breakpoint conditions or watchpoint expressions that include
5638 inferior function calls. */
c5aa993b 5639
429374b8
JK
5640 ALL_BREAKPOINTS (b)
5641 {
1a853c52 5642 if (!breakpoint_enabled (b))
429374b8 5643 continue;
a5606eee 5644
429374b8
JK
5645 for (bl = b->loc; bl != NULL; bl = bl->next)
5646 {
4a64f543
MS
5647 /* For hardware watchpoints, we look only at the first
5648 location. The watchpoint_check function will work on the
5649 entire expression, not the individual locations. For
5650 read watchpoints, the watchpoints_triggered function has
5651 checked all locations already. */
429374b8
JK
5652 if (b->type == bp_hardware_watchpoint && bl != b->loc)
5653 break;
18a18393 5654
f6592439 5655 if (!bl->enabled || bl->shlib_disabled)
429374b8 5656 continue;
c5aa993b 5657
09ac7c10 5658 if (!bpstat_check_location (bl, aspace, bp_addr, ws))
429374b8 5659 continue;
c5aa993b 5660
4a64f543
MS
5661 /* Come here if it's a watchpoint, or if the break address
5662 matches. */
c5aa993b 5663
4a64f543
MS
5664 bs = bpstat_alloc (bl, &bs_link); /* Alloc a bpstat to
5665 explain stop. */
c5aa993b 5666
f431efe5
PA
5667 /* Assume we stop. Should we find a watchpoint that is not
5668 actually triggered, or if the condition of the breakpoint
5669 evaluates as false, we'll reset 'stop' to 0. */
429374b8
JK
5670 bs->stop = 1;
5671 bs->print = 1;
d983da9c 5672
f431efe5
PA
5673 /* If this is a scope breakpoint, mark the associated
5674 watchpoint as triggered so that we will handle the
5675 out-of-scope event. We'll get to the watchpoint next
5676 iteration. */
d0fb5eae 5677 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
3a5c3e22
PA
5678 {
5679 struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5680
5681 w->watchpoint_triggered = watch_triggered_yes;
5682 }
f431efe5
PA
5683 }
5684 }
5685
7c16b83e 5686 /* Check if a moribund breakpoint explains the stop. */
1cf4d951
PA
5687 if (!target_supports_stopped_by_sw_breakpoint ()
5688 || !target_supports_stopped_by_hw_breakpoint ())
f431efe5 5689 {
1cf4d951 5690 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
f431efe5 5691 {
1cf4d951
PA
5692 if (breakpoint_location_address_match (loc, aspace, bp_addr)
5693 && need_moribund_for_location_type (loc))
5694 {
5695 bs = bpstat_alloc (loc, &bs_link);
5696 /* For hits of moribund locations, we should just proceed. */
5697 bs->stop = 0;
5698 bs->print = 0;
5699 bs->print_it = print_it_noop;
5700 }
f431efe5
PA
5701 }
5702 }
5703
edcc5120
TT
5704 /* A bit of special processing for shlib breakpoints. We need to
5705 process solib loading here, so that the lists of loaded and
5706 unloaded libraries are correct before we handle "catch load" and
5707 "catch unload". */
5708 for (bs = bs_head; bs != NULL; bs = bs->next)
5709 {
5d268276 5710 if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
edcc5120
TT
5711 {
5712 handle_solib_event ();
5713 break;
5714 }
5715 }
5716
f431efe5
PA
5717 /* Now go through the locations that caused the target to stop, and
5718 check whether we're interested in reporting this stop to higher
5719 layers, or whether we should resume the target transparently. */
5720
5721 removed_any = 0;
5722
5760d0ab 5723 for (bs = bs_head; bs != NULL; bs = bs->next)
f431efe5
PA
5724 {
5725 if (!bs->stop)
5726 continue;
5727
f431efe5 5728 b = bs->breakpoint_at;
348d480f
PA
5729 b->ops->check_status (bs);
5730 if (bs->stop)
28010a5d 5731 {
348d480f 5732 bpstat_check_breakpoint_conditions (bs, ptid);
f431efe5 5733
429374b8
JK
5734 if (bs->stop)
5735 {
5736 ++(b->hit_count);
8d3788bd 5737 observer_notify_breakpoint_modified (b);
c906108c 5738
4a64f543 5739 /* We will stop here. */
429374b8
JK
5740 if (b->disposition == disp_disable)
5741 {
816338b5 5742 --(b->enable_count);
1a853c52 5743 if (b->enable_count <= 0)
429374b8 5744 b->enable_state = bp_disabled;
f431efe5 5745 removed_any = 1;
429374b8
JK
5746 }
5747 if (b->silent)
5748 bs->print = 0;
5749 bs->commands = b->commands;
9add0f1b 5750 incref_counted_command_line (bs->commands);
abf85f46
JK
5751 if (command_line_is_silent (bs->commands
5752 ? bs->commands->commands : NULL))
5753 bs->print = 0;
9d6e6e84
HZ
5754
5755 b->ops->after_condition_true (bs);
429374b8
JK
5756 }
5757
348d480f 5758 }
a9b3a50f
PA
5759
5760 /* Print nothing for this entry if we don't stop or don't
5761 print. */
5762 if (!bs->stop || !bs->print)
5763 bs->print_it = print_it_noop;
429374b8 5764 }
876fa593 5765
d983da9c
DJ
5766 /* If we aren't stopping, the value of some hardware watchpoint may
5767 not have changed, but the intermediate memory locations we are
5768 watching may have. Don't bother if we're stopping; this will get
5769 done later. */
d832cb68 5770 need_remove_insert = 0;
5760d0ab
JK
5771 if (! bpstat_causes_stop (bs_head))
5772 for (bs = bs_head; bs != NULL; bs = bs->next)
d983da9c 5773 if (!bs->stop
f431efe5
PA
5774 && bs->breakpoint_at
5775 && is_hardware_watchpoint (bs->breakpoint_at))
d983da9c 5776 {
3a5c3e22
PA
5777 struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5778
5779 update_watchpoint (w, 0 /* don't reparse. */);
d832cb68 5780 need_remove_insert = 1;
d983da9c
DJ
5781 }
5782
d832cb68 5783 if (need_remove_insert)
44702360 5784 update_global_location_list (UGLL_MAY_INSERT);
f431efe5 5785 else if (removed_any)
44702360 5786 update_global_location_list (UGLL_DONT_INSERT);
d832cb68 5787
5760d0ab 5788 return bs_head;
c906108c 5789}
628fe4e4
JK
5790
5791static void
5792handle_jit_event (void)
5793{
5794 struct frame_info *frame;
5795 struct gdbarch *gdbarch;
5796
243a9253
PA
5797 if (debug_infrun)
5798 fprintf_unfiltered (gdb_stdlog, "handling bp_jit_event\n");
5799
628fe4e4
JK
5800 /* Switch terminal for any messages produced by
5801 breakpoint_re_set. */
5802 target_terminal_ours_for_output ();
5803
5804 frame = get_current_frame ();
5805 gdbarch = get_frame_arch (frame);
5806
5807 jit_event_handler (gdbarch);
5808
5809 target_terminal_inferior ();
5810}
5811
5812/* Prepare WHAT final decision for infrun. */
5813
5814/* Decide what infrun needs to do with this bpstat. */
5815
c906108c 5816struct bpstat_what
0e30163f 5817bpstat_what (bpstat bs_head)
c906108c 5818{
c906108c 5819 struct bpstat_what retval;
0e30163f 5820 bpstat bs;
c906108c 5821
628fe4e4 5822 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
aa7d318d 5823 retval.call_dummy = STOP_NONE;
186c406b 5824 retval.is_longjmp = 0;
628fe4e4 5825
0e30163f 5826 for (bs = bs_head; bs != NULL; bs = bs->next)
c906108c 5827 {
628fe4e4
JK
5828 /* Extract this BS's action. After processing each BS, we check
5829 if its action overrides all we've seem so far. */
5830 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5831 enum bptype bptype;
5832
c906108c 5833 if (bs->breakpoint_at == NULL)
628fe4e4
JK
5834 {
5835 /* I suspect this can happen if it was a momentary
5836 breakpoint which has since been deleted. */
5837 bptype = bp_none;
5838 }
20874c92 5839 else
f431efe5 5840 bptype = bs->breakpoint_at->type;
628fe4e4
JK
5841
5842 switch (bptype)
c906108c
SS
5843 {
5844 case bp_none:
628fe4e4 5845 break;
c906108c
SS
5846 case bp_breakpoint:
5847 case bp_hardware_breakpoint:
7c16b83e 5848 case bp_single_step:
c906108c
SS
5849 case bp_until:
5850 case bp_finish:
a9b3a50f 5851 case bp_shlib_event:
c906108c
SS
5852 if (bs->stop)
5853 {
5854 if (bs->print)
628fe4e4 5855 this_action = BPSTAT_WHAT_STOP_NOISY;
c906108c 5856 else
628fe4e4 5857 this_action = BPSTAT_WHAT_STOP_SILENT;
c906108c
SS
5858 }
5859 else
628fe4e4 5860 this_action = BPSTAT_WHAT_SINGLE;
c906108c
SS
5861 break;
5862 case bp_watchpoint:
5863 case bp_hardware_watchpoint:
5864 case bp_read_watchpoint:
5865 case bp_access_watchpoint:
5866 if (bs->stop)
5867 {
5868 if (bs->print)
628fe4e4 5869 this_action = BPSTAT_WHAT_STOP_NOISY;
c906108c 5870 else
628fe4e4 5871 this_action = BPSTAT_WHAT_STOP_SILENT;
c906108c
SS
5872 }
5873 else
628fe4e4
JK
5874 {
5875 /* There was a watchpoint, but we're not stopping.
5876 This requires no further action. */
5877 }
c906108c
SS
5878 break;
5879 case bp_longjmp:
e2e4d78b 5880 case bp_longjmp_call_dummy:
186c406b 5881 case bp_exception:
0a39bb32
PA
5882 if (bs->stop)
5883 {
5884 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5885 retval.is_longjmp = bptype != bp_exception;
5886 }
5887 else
5888 this_action = BPSTAT_WHAT_SINGLE;
c906108c
SS
5889 break;
5890 case bp_longjmp_resume:
186c406b 5891 case bp_exception_resume:
0a39bb32
PA
5892 if (bs->stop)
5893 {
5894 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5895 retval.is_longjmp = bptype == bp_longjmp_resume;
5896 }
5897 else
5898 this_action = BPSTAT_WHAT_SINGLE;
c906108c
SS
5899 break;
5900 case bp_step_resume:
5901 if (bs->stop)
628fe4e4
JK
5902 this_action = BPSTAT_WHAT_STEP_RESUME;
5903 else
c906108c 5904 {
628fe4e4
JK
5905 /* It is for the wrong frame. */
5906 this_action = BPSTAT_WHAT_SINGLE;
c906108c 5907 }
c906108c 5908 break;
2c03e5be
PA
5909 case bp_hp_step_resume:
5910 if (bs->stop)
5911 this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5912 else
5913 {
5914 /* It is for the wrong frame. */
5915 this_action = BPSTAT_WHAT_SINGLE;
5916 }
5917 break;
c906108c 5918 case bp_watchpoint_scope:
c4093a6a 5919 case bp_thread_event:
1900040c 5920 case bp_overlay_event:
0fd8e87f 5921 case bp_longjmp_master:
aa7d318d 5922 case bp_std_terminate_master:
186c406b 5923 case bp_exception_master:
628fe4e4 5924 this_action = BPSTAT_WHAT_SINGLE;
c4093a6a 5925 break;
ce78b96d 5926 case bp_catchpoint:
c5aa993b
JM
5927 if (bs->stop)
5928 {
5929 if (bs->print)
628fe4e4 5930 this_action = BPSTAT_WHAT_STOP_NOISY;
c5aa993b 5931 else
628fe4e4 5932 this_action = BPSTAT_WHAT_STOP_SILENT;
c5aa993b
JM
5933 }
5934 else
628fe4e4
JK
5935 {
5936 /* There was a catchpoint, but we're not stopping.
5937 This requires no further action. */
5938 }
5939 break;
628fe4e4 5940 case bp_jit_event:
628fe4e4 5941 this_action = BPSTAT_WHAT_SINGLE;
c5aa993b 5942 break;
c906108c 5943 case bp_call_dummy:
53a5351d
JM
5944 /* Make sure the action is stop (silent or noisy),
5945 so infrun.c pops the dummy frame. */
aa7d318d 5946 retval.call_dummy = STOP_STACK_DUMMY;
628fe4e4 5947 this_action = BPSTAT_WHAT_STOP_SILENT;
aa7d318d
TT
5948 break;
5949 case bp_std_terminate:
5950 /* Make sure the action is stop (silent or noisy),
5951 so infrun.c pops the dummy frame. */
aa7d318d 5952 retval.call_dummy = STOP_STD_TERMINATE;
628fe4e4 5953 this_action = BPSTAT_WHAT_STOP_SILENT;
c906108c 5954 break;
1042e4c0 5955 case bp_tracepoint:
7a697b8d 5956 case bp_fast_tracepoint:
0fb4aa4b 5957 case bp_static_tracepoint:
1042e4c0
SS
5958 /* Tracepoint hits should not be reported back to GDB, and
5959 if one got through somehow, it should have been filtered
5960 out already. */
5961 internal_error (__FILE__, __LINE__,
7a697b8d 5962 _("bpstat_what: tracepoint encountered"));
0e30163f
JK
5963 break;
5964 case bp_gnu_ifunc_resolver:
5965 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5966 this_action = BPSTAT_WHAT_SINGLE;
5967 break;
5968 case bp_gnu_ifunc_resolver_return:
5969 /* The breakpoint will be removed, execution will restart from the
5970 PC of the former breakpoint. */
5971 this_action = BPSTAT_WHAT_KEEP_CHECKING;
5972 break;
e7e0cddf
SS
5973
5974 case bp_dprintf:
a11cfd87
HZ
5975 if (bs->stop)
5976 this_action = BPSTAT_WHAT_STOP_SILENT;
5977 else
5978 this_action = BPSTAT_WHAT_SINGLE;
e7e0cddf
SS
5979 break;
5980
628fe4e4
JK
5981 default:
5982 internal_error (__FILE__, __LINE__,
5983 _("bpstat_what: unhandled bptype %d"), (int) bptype);
c906108c 5984 }
628fe4e4 5985
325fac50 5986 retval.main_action = std::max (retval.main_action, this_action);
c906108c 5987 }
628fe4e4 5988
243a9253
PA
5989 return retval;
5990}
628fe4e4 5991
243a9253
PA
5992void
5993bpstat_run_callbacks (bpstat bs_head)
5994{
5995 bpstat bs;
628fe4e4 5996
0e30163f
JK
5997 for (bs = bs_head; bs != NULL; bs = bs->next)
5998 {
5999 struct breakpoint *b = bs->breakpoint_at;
6000
6001 if (b == NULL)
6002 continue;
6003 switch (b->type)
6004 {
243a9253
PA
6005 case bp_jit_event:
6006 handle_jit_event ();
6007 break;
0e30163f
JK
6008 case bp_gnu_ifunc_resolver:
6009 gnu_ifunc_resolver_stop (b);
6010 break;
6011 case bp_gnu_ifunc_resolver_return:
6012 gnu_ifunc_resolver_return_stop (b);
6013 break;
6014 }
6015 }
c906108c
SS
6016}
6017
6018/* Nonzero if we should step constantly (e.g. watchpoints on machines
6019 without hardware support). This isn't related to a specific bpstat,
6020 just to things like whether watchpoints are set. */
6021
c5aa993b 6022int
fba45db2 6023bpstat_should_step (void)
c906108c
SS
6024{
6025 struct breakpoint *b;
cc59ec59 6026
c906108c 6027 ALL_BREAKPOINTS (b)
717a8278 6028 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
3172dc30 6029 return 1;
c906108c
SS
6030 return 0;
6031}
6032
67822962
PA
6033int
6034bpstat_causes_stop (bpstat bs)
6035{
6036 for (; bs != NULL; bs = bs->next)
6037 if (bs->stop)
6038 return 1;
6039
6040 return 0;
6041}
6042
c906108c 6043\f
c5aa993b 6044
170b53b2
UW
6045/* Compute a string of spaces suitable to indent the next line
6046 so it starts at the position corresponding to the table column
6047 named COL_NAME in the currently active table of UIOUT. */
6048
6049static char *
6050wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
6051{
6052 static char wrap_indent[80];
6053 int i, total_width, width, align;
c5209615 6054 const char *text;
170b53b2
UW
6055
6056 total_width = 0;
112e8700 6057 for (i = 1; uiout->query_table_field (i, &width, &align, &text); i++)
170b53b2
UW
6058 {
6059 if (strcmp (text, col_name) == 0)
6060 {
6061 gdb_assert (total_width < sizeof wrap_indent);
6062 memset (wrap_indent, ' ', total_width);
6063 wrap_indent[total_width] = 0;
6064
6065 return wrap_indent;
6066 }
6067
6068 total_width += width + 1;
6069 }
6070
6071 return NULL;
6072}
6073
b775012e
LM
6074/* Determine if the locations of this breakpoint will have their conditions
6075 evaluated by the target, host or a mix of both. Returns the following:
6076
6077 "host": Host evals condition.
6078 "host or target": Host or Target evals condition.
6079 "target": Target evals condition.
6080*/
6081
6082static const char *
6083bp_condition_evaluator (struct breakpoint *b)
6084{
6085 struct bp_location *bl;
6086 char host_evals = 0;
6087 char target_evals = 0;
6088
6089 if (!b)
6090 return NULL;
6091
6092 if (!is_breakpoint (b))
6093 return NULL;
6094
6095 if (gdb_evaluates_breakpoint_condition_p ()
6096 || !target_supports_evaluation_of_breakpoint_conditions ())
6097 return condition_evaluation_host;
6098
6099 for (bl = b->loc; bl; bl = bl->next)
6100 {
6101 if (bl->cond_bytecode)
6102 target_evals++;
6103 else
6104 host_evals++;
6105 }
6106
6107 if (host_evals && target_evals)
6108 return condition_evaluation_both;
6109 else if (target_evals)
6110 return condition_evaluation_target;
6111 else
6112 return condition_evaluation_host;
6113}
6114
6115/* Determine the breakpoint location's condition evaluator. This is
6116 similar to bp_condition_evaluator, but for locations. */
6117
6118static const char *
6119bp_location_condition_evaluator (struct bp_location *bl)
6120{
6121 if (bl && !is_breakpoint (bl->owner))
6122 return NULL;
6123
6124 if (gdb_evaluates_breakpoint_condition_p ()
6125 || !target_supports_evaluation_of_breakpoint_conditions ())
6126 return condition_evaluation_host;
6127
6128 if (bl && bl->cond_bytecode)
6129 return condition_evaluation_target;
6130 else
6131 return condition_evaluation_host;
6132}
6133
859825b8
JK
6134/* Print the LOC location out of the list of B->LOC locations. */
6135
170b53b2
UW
6136static void
6137print_breakpoint_location (struct breakpoint *b,
6138 struct bp_location *loc)
0d381245 6139{
79a45e25 6140 struct ui_out *uiout = current_uiout;
6c95b8df
PA
6141 struct cleanup *old_chain = save_current_program_space ();
6142
859825b8
JK
6143 if (loc != NULL && loc->shlib_disabled)
6144 loc = NULL;
6145
6c95b8df
PA
6146 if (loc != NULL)
6147 set_current_program_space (loc->pspace);
6148
56435ebe 6149 if (b->display_canonical)
d28cd78a 6150 uiout->field_string ("what", event_location_to_string (b->location.get ()));
2f202fde 6151 else if (loc && loc->symtab)
0d381245
VP
6152 {
6153 struct symbol *sym
6154 = find_pc_sect_function (loc->address, loc->section);
6155 if (sym)
6156 {
112e8700
SM
6157 uiout->text ("in ");
6158 uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
6159 uiout->text (" ");
6160 uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
6161 uiout->text ("at ");
0d381245 6162 }
112e8700 6163 uiout->field_string ("file",
05cba821 6164 symtab_to_filename_for_display (loc->symtab));
112e8700 6165 uiout->text (":");
05cba821 6166
112e8700
SM
6167 if (uiout->is_mi_like_p ())
6168 uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
0d381245 6169
112e8700 6170 uiout->field_int ("line", loc->line_number);
0d381245 6171 }
859825b8 6172 else if (loc)
0d381245 6173 {
d7e74731 6174 string_file stb;
170b53b2 6175
d7e74731 6176 print_address_symbolic (loc->gdbarch, loc->address, &stb,
22e722e1 6177 demangle, "");
112e8700 6178 uiout->field_stream ("at", stb);
0d381245 6179 }
859825b8 6180 else
f00aae0f 6181 {
d28cd78a
TT
6182 uiout->field_string ("pending",
6183 event_location_to_string (b->location.get ()));
f00aae0f
KS
6184 /* If extra_string is available, it could be holding a condition
6185 or dprintf arguments. In either case, make sure it is printed,
6186 too, but only for non-MI streams. */
112e8700 6187 if (!uiout->is_mi_like_p () && b->extra_string != NULL)
f00aae0f
KS
6188 {
6189 if (b->type == bp_dprintf)
112e8700 6190 uiout->text (",");
f00aae0f 6191 else
112e8700
SM
6192 uiout->text (" ");
6193 uiout->text (b->extra_string);
f00aae0f
KS
6194 }
6195 }
6c95b8df 6196
b775012e
LM
6197 if (loc && is_breakpoint (b)
6198 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6199 && bp_condition_evaluator (b) == condition_evaluation_both)
6200 {
112e8700
SM
6201 uiout->text (" (");
6202 uiout->field_string ("evaluated-by",
b775012e 6203 bp_location_condition_evaluator (loc));
112e8700 6204 uiout->text (")");
b775012e
LM
6205 }
6206
6c95b8df 6207 do_cleanups (old_chain);
0d381245
VP
6208}
6209
269b11a2
PA
6210static const char *
6211bptype_string (enum bptype type)
c906108c 6212{
c4093a6a
JM
6213 struct ep_type_description
6214 {
6215 enum bptype type;
a121b7c1 6216 const char *description;
c4093a6a
JM
6217 };
6218 static struct ep_type_description bptypes[] =
c906108c 6219 {
c5aa993b
JM
6220 {bp_none, "?deleted?"},
6221 {bp_breakpoint, "breakpoint"},
c906108c 6222 {bp_hardware_breakpoint, "hw breakpoint"},
7c16b83e 6223 {bp_single_step, "sw single-step"},
c5aa993b
JM
6224 {bp_until, "until"},
6225 {bp_finish, "finish"},
6226 {bp_watchpoint, "watchpoint"},
c906108c 6227 {bp_hardware_watchpoint, "hw watchpoint"},
c5aa993b
JM
6228 {bp_read_watchpoint, "read watchpoint"},
6229 {bp_access_watchpoint, "acc watchpoint"},
6230 {bp_longjmp, "longjmp"},
6231 {bp_longjmp_resume, "longjmp resume"},
e2e4d78b 6232 {bp_longjmp_call_dummy, "longjmp for call dummy"},
186c406b
TT
6233 {bp_exception, "exception"},
6234 {bp_exception_resume, "exception resume"},
c5aa993b 6235 {bp_step_resume, "step resume"},
2c03e5be 6236 {bp_hp_step_resume, "high-priority step resume"},
c5aa993b
JM
6237 {bp_watchpoint_scope, "watchpoint scope"},
6238 {bp_call_dummy, "call dummy"},
aa7d318d 6239 {bp_std_terminate, "std::terminate"},
c5aa993b 6240 {bp_shlib_event, "shlib events"},
c4093a6a 6241 {bp_thread_event, "thread events"},
1900040c 6242 {bp_overlay_event, "overlay events"},
0fd8e87f 6243 {bp_longjmp_master, "longjmp master"},
aa7d318d 6244 {bp_std_terminate_master, "std::terminate master"},
186c406b 6245 {bp_exception_master, "exception master"},
ce78b96d 6246 {bp_catchpoint, "catchpoint"},
1042e4c0 6247 {bp_tracepoint, "tracepoint"},
7a697b8d 6248 {bp_fast_tracepoint, "fast tracepoint"},
0fb4aa4b 6249 {bp_static_tracepoint, "static tracepoint"},
e7e0cddf 6250 {bp_dprintf, "dprintf"},
4efc6507 6251 {bp_jit_event, "jit events"},
0e30163f
JK
6252 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
6253 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
c5aa993b 6254 };
269b11a2
PA
6255
6256 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
6257 || ((int) type != bptypes[(int) type].type))
6258 internal_error (__FILE__, __LINE__,
6259 _("bptypes table does not describe type #%d."),
6260 (int) type);
6261
6262 return bptypes[(int) type].description;
6263}
6264
998580f1
MK
6265/* For MI, output a field named 'thread-groups' with a list as the value.
6266 For CLI, prefix the list with the string 'inf'. */
6267
6268static void
6269output_thread_groups (struct ui_out *uiout,
6270 const char *field_name,
6271 VEC(int) *inf_num,
6272 int mi_only)
6273{
752eb8b4 6274 struct cleanup *back_to;
112e8700 6275 int is_mi = uiout->is_mi_like_p ();
998580f1
MK
6276 int inf;
6277 int i;
6278
6279 /* For backward compatibility, don't display inferiors in CLI unless
6280 there are several. Always display them for MI. */
6281 if (!is_mi && mi_only)
6282 return;
6283
752eb8b4
TT
6284 back_to = make_cleanup_ui_out_list_begin_end (uiout, field_name);
6285
998580f1
MK
6286 for (i = 0; VEC_iterate (int, inf_num, i, inf); ++i)
6287 {
6288 if (is_mi)
6289 {
6290 char mi_group[10];
6291
6292 xsnprintf (mi_group, sizeof (mi_group), "i%d", inf);
112e8700 6293 uiout->field_string (NULL, mi_group);
998580f1
MK
6294 }
6295 else
6296 {
6297 if (i == 0)
112e8700 6298 uiout->text (" inf ");
998580f1 6299 else
112e8700 6300 uiout->text (", ");
998580f1 6301
112e8700 6302 uiout->text (plongest (inf));
998580f1
MK
6303 }
6304 }
6305
6306 do_cleanups (back_to);
6307}
6308
269b11a2
PA
6309/* Print B to gdb_stdout. */
6310
6311static void
6312print_one_breakpoint_location (struct breakpoint *b,
6313 struct bp_location *loc,
6314 int loc_number,
6315 struct bp_location **last_loc,
269b11a2
PA
6316 int allflag)
6317{
6318 struct command_line *l;
c2c6d25f 6319 static char bpenables[] = "nynny";
c906108c 6320
79a45e25 6321 struct ui_out *uiout = current_uiout;
0d381245
VP
6322 int header_of_multiple = 0;
6323 int part_of_multiple = (loc != NULL);
79a45b7d
TT
6324 struct value_print_options opts;
6325
6326 get_user_print_options (&opts);
0d381245
VP
6327
6328 gdb_assert (!loc || loc_number != 0);
4a64f543
MS
6329 /* See comment in print_one_breakpoint concerning treatment of
6330 breakpoints with single disabled location. */
0d381245
VP
6331 if (loc == NULL
6332 && (b->loc != NULL
6333 && (b->loc->next != NULL || !b->loc->enabled)))
6334 header_of_multiple = 1;
6335 if (loc == NULL)
6336 loc = b->loc;
6337
c4093a6a
JM
6338 annotate_record ();
6339
6340 /* 1 */
6341 annotate_field (0);
0d381245
VP
6342 if (part_of_multiple)
6343 {
6344 char *formatted;
0c6773c1 6345 formatted = xstrprintf ("%d.%d", b->number, loc_number);
112e8700 6346 uiout->field_string ("number", formatted);
0d381245
VP
6347 xfree (formatted);
6348 }
6349 else
6350 {
112e8700 6351 uiout->field_int ("number", b->number);
0d381245 6352 }
c4093a6a
JM
6353
6354 /* 2 */
6355 annotate_field (1);
0d381245 6356 if (part_of_multiple)
112e8700 6357 uiout->field_skip ("type");
269b11a2 6358 else
112e8700 6359 uiout->field_string ("type", bptype_string (b->type));
c4093a6a
JM
6360
6361 /* 3 */
6362 annotate_field (2);
0d381245 6363 if (part_of_multiple)
112e8700 6364 uiout->field_skip ("disp");
0d381245 6365 else
112e8700 6366 uiout->field_string ("disp", bpdisp_text (b->disposition));
0d381245 6367
c4093a6a
JM
6368
6369 /* 4 */
6370 annotate_field (3);
0d381245 6371 if (part_of_multiple)
112e8700 6372 uiout->field_string ("enabled", loc->enabled ? "y" : "n");
0d381245 6373 else
112e8700
SM
6374 uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
6375 uiout->spaces (2);
0d381245 6376
c4093a6a
JM
6377
6378 /* 5 and 6 */
3086aeae 6379 if (b->ops != NULL && b->ops->print_one != NULL)
0d381245 6380 {
4a64f543
MS
6381 /* Although the print_one can possibly print all locations,
6382 calling it here is not likely to get any nice result. So,
6383 make sure there's just one location. */
0d381245 6384 gdb_assert (b->loc == NULL || b->loc->next == NULL);
a6d9a66e 6385 b->ops->print_one (b, last_loc);
0d381245 6386 }
3086aeae
DJ
6387 else
6388 switch (b->type)
6389 {
6390 case bp_none:
6391 internal_error (__FILE__, __LINE__,
e2e0b3e5 6392 _("print_one_breakpoint: bp_none encountered\n"));
3086aeae 6393 break;
c906108c 6394
3086aeae
DJ
6395 case bp_watchpoint:
6396 case bp_hardware_watchpoint:
6397 case bp_read_watchpoint:
6398 case bp_access_watchpoint:
3a5c3e22
PA
6399 {
6400 struct watchpoint *w = (struct watchpoint *) b;
6401
6402 /* Field 4, the address, is omitted (which makes the columns
6403 not line up too nicely with the headers, but the effect
6404 is relatively readable). */
6405 if (opts.addressprint)
112e8700 6406 uiout->field_skip ("addr");
3a5c3e22 6407 annotate_field (5);
112e8700 6408 uiout->field_string ("what", w->exp_string);
3a5c3e22 6409 }
3086aeae
DJ
6410 break;
6411
3086aeae
DJ
6412 case bp_breakpoint:
6413 case bp_hardware_breakpoint:
7c16b83e 6414 case bp_single_step:
3086aeae
DJ
6415 case bp_until:
6416 case bp_finish:
6417 case bp_longjmp:
6418 case bp_longjmp_resume:
e2e4d78b 6419 case bp_longjmp_call_dummy:
186c406b
TT
6420 case bp_exception:
6421 case bp_exception_resume:
3086aeae 6422 case bp_step_resume:
2c03e5be 6423 case bp_hp_step_resume:
3086aeae
DJ
6424 case bp_watchpoint_scope:
6425 case bp_call_dummy:
aa7d318d 6426 case bp_std_terminate:
3086aeae
DJ
6427 case bp_shlib_event:
6428 case bp_thread_event:
6429 case bp_overlay_event:
0fd8e87f 6430 case bp_longjmp_master:
aa7d318d 6431 case bp_std_terminate_master:
186c406b 6432 case bp_exception_master:
1042e4c0 6433 case bp_tracepoint:
7a697b8d 6434 case bp_fast_tracepoint:
0fb4aa4b 6435 case bp_static_tracepoint:
e7e0cddf 6436 case bp_dprintf:
4efc6507 6437 case bp_jit_event:
0e30163f
JK
6438 case bp_gnu_ifunc_resolver:
6439 case bp_gnu_ifunc_resolver_return:
79a45b7d 6440 if (opts.addressprint)
3086aeae
DJ
6441 {
6442 annotate_field (4);
54e52265 6443 if (header_of_multiple)
112e8700 6444 uiout->field_string ("addr", "<MULTIPLE>");
e9bbd7c5 6445 else if (b->loc == NULL || loc->shlib_disabled)
112e8700 6446 uiout->field_string ("addr", "<PENDING>");
0101ce28 6447 else
112e8700 6448 uiout->field_core_addr ("addr",
5af949e3 6449 loc->gdbarch, loc->address);
3086aeae
DJ
6450 }
6451 annotate_field (5);
0d381245 6452 if (!header_of_multiple)
170b53b2 6453 print_breakpoint_location (b, loc);
0d381245 6454 if (b->loc)
a6d9a66e 6455 *last_loc = b->loc;
3086aeae
DJ
6456 break;
6457 }
c906108c 6458
6c95b8df 6459
998580f1 6460 if (loc != NULL && !header_of_multiple)
6c95b8df
PA
6461 {
6462 struct inferior *inf;
998580f1
MK
6463 VEC(int) *inf_num = NULL;
6464 int mi_only = 1;
6c95b8df 6465
998580f1 6466 ALL_INFERIORS (inf)
6c95b8df
PA
6467 {
6468 if (inf->pspace == loc->pspace)
998580f1 6469 VEC_safe_push (int, inf_num, inf->num);
6c95b8df 6470 }
998580f1
MK
6471
6472 /* For backward compatibility, don't display inferiors in CLI unless
6473 there are several. Always display for MI. */
6474 if (allflag
6475 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6476 && (number_of_program_spaces () > 1
6477 || number_of_inferiors () > 1)
6478 /* LOC is for existing B, it cannot be in
6479 moribund_locations and thus having NULL OWNER. */
6480 && loc->owner->type != bp_catchpoint))
6481 mi_only = 0;
6482 output_thread_groups (uiout, "thread-groups", inf_num, mi_only);
6483 VEC_free (int, inf_num);
6c95b8df
PA
6484 }
6485
4a306c9a 6486 if (!part_of_multiple)
c4093a6a 6487 {
4a306c9a
JB
6488 if (b->thread != -1)
6489 {
6490 /* FIXME: This seems to be redundant and lost here; see the
4a64f543 6491 "stop only in" line a little further down. */
112e8700
SM
6492 uiout->text (" thread ");
6493 uiout->field_int ("thread", b->thread);
4a306c9a
JB
6494 }
6495 else if (b->task != 0)
6496 {
112e8700
SM
6497 uiout->text (" task ");
6498 uiout->field_int ("task", b->task);
4a306c9a 6499 }
c4093a6a 6500 }
f1310107 6501
112e8700 6502 uiout->text ("\n");
f1310107 6503
348d480f 6504 if (!part_of_multiple)
f1310107
TJB
6505 b->ops->print_one_detail (b, uiout);
6506
0d381245 6507 if (part_of_multiple && frame_id_p (b->frame_id))
c4093a6a
JM
6508 {
6509 annotate_field (6);
112e8700 6510 uiout->text ("\tstop only in stack frame at ");
e5dd4106 6511 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
818dd999 6512 the frame ID. */
112e8700 6513 uiout->field_core_addr ("frame",
5af949e3 6514 b->gdbarch, b->frame_id.stack_addr);
112e8700 6515 uiout->text ("\n");
c4093a6a
JM
6516 }
6517
28010a5d 6518 if (!part_of_multiple && b->cond_string)
c4093a6a
JM
6519 {
6520 annotate_field (7);
d77f58be 6521 if (is_tracepoint (b))
112e8700 6522 uiout->text ("\ttrace only if ");
1042e4c0 6523 else
112e8700
SM
6524 uiout->text ("\tstop only if ");
6525 uiout->field_string ("cond", b->cond_string);
b775012e
LM
6526
6527 /* Print whether the target is doing the breakpoint's condition
6528 evaluation. If GDB is doing the evaluation, don't print anything. */
6529 if (is_breakpoint (b)
6530 && breakpoint_condition_evaluation_mode ()
6531 == condition_evaluation_target)
6532 {
112e8700
SM
6533 uiout->text (" (");
6534 uiout->field_string ("evaluated-by",
b775012e 6535 bp_condition_evaluator (b));
112e8700 6536 uiout->text (" evals)");
b775012e 6537 }
112e8700 6538 uiout->text ("\n");
0101ce28
JJ
6539 }
6540
0d381245 6541 if (!part_of_multiple && b->thread != -1)
c4093a6a 6542 {
4a64f543 6543 /* FIXME should make an annotation for this. */
112e8700
SM
6544 uiout->text ("\tstop only in thread ");
6545 if (uiout->is_mi_like_p ())
6546 uiout->field_int ("thread", b->thread);
5d5658a1
PA
6547 else
6548 {
6549 struct thread_info *thr = find_thread_global_id (b->thread);
6550
112e8700 6551 uiout->field_string ("thread", print_thread_id (thr));
5d5658a1 6552 }
112e8700 6553 uiout->text ("\n");
c4093a6a
JM
6554 }
6555
556ec64d
YQ
6556 if (!part_of_multiple)
6557 {
6558 if (b->hit_count)
31f56a27
YQ
6559 {
6560 /* FIXME should make an annotation for this. */
6561 if (is_catchpoint (b))
112e8700 6562 uiout->text ("\tcatchpoint");
31f56a27 6563 else if (is_tracepoint (b))
112e8700 6564 uiout->text ("\ttracepoint");
31f56a27 6565 else
112e8700
SM
6566 uiout->text ("\tbreakpoint");
6567 uiout->text (" already hit ");
6568 uiout->field_int ("times", b->hit_count);
31f56a27 6569 if (b->hit_count == 1)
112e8700 6570 uiout->text (" time\n");
31f56a27 6571 else
112e8700 6572 uiout->text (" times\n");
31f56a27 6573 }
556ec64d
YQ
6574 else
6575 {
31f56a27 6576 /* Output the count also if it is zero, but only if this is mi. */
112e8700
SM
6577 if (uiout->is_mi_like_p ())
6578 uiout->field_int ("times", b->hit_count);
556ec64d
YQ
6579 }
6580 }
8b93c638 6581
0d381245 6582 if (!part_of_multiple && b->ignore_count)
c4093a6a
JM
6583 {
6584 annotate_field (8);
112e8700
SM
6585 uiout->text ("\tignore next ");
6586 uiout->field_int ("ignore", b->ignore_count);
6587 uiout->text (" hits\n");
c4093a6a 6588 }
059fb39f 6589
816338b5
SS
6590 /* Note that an enable count of 1 corresponds to "enable once"
6591 behavior, which is reported by the combination of enablement and
6592 disposition, so we don't need to mention it here. */
6593 if (!part_of_multiple && b->enable_count > 1)
6594 {
6595 annotate_field (8);
112e8700 6596 uiout->text ("\tdisable after ");
816338b5
SS
6597 /* Tweak the wording to clarify that ignore and enable counts
6598 are distinct, and have additive effect. */
6599 if (b->ignore_count)
112e8700 6600 uiout->text ("additional ");
816338b5 6601 else
112e8700
SM
6602 uiout->text ("next ");
6603 uiout->field_int ("enable", b->enable_count);
6604 uiout->text (" hits\n");
816338b5
SS
6605 }
6606
f196051f
SS
6607 if (!part_of_multiple && is_tracepoint (b))
6608 {
6609 struct tracepoint *tp = (struct tracepoint *) b;
6610
6611 if (tp->traceframe_usage)
6612 {
112e8700
SM
6613 uiout->text ("\ttrace buffer usage ");
6614 uiout->field_int ("traceframe-usage", tp->traceframe_usage);
6615 uiout->text (" bytes\n");
f196051f
SS
6616 }
6617 }
d3ce09f5 6618
9add0f1b 6619 l = b->commands ? b->commands->commands : NULL;
059fb39f 6620 if (!part_of_multiple && l)
c4093a6a 6621 {
3b31d625
EZ
6622 struct cleanup *script_chain;
6623
c4093a6a 6624 annotate_field (9);
3b31d625 6625 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
8b93c638 6626 print_command_lines (uiout, l, 4);
3b31d625 6627 do_cleanups (script_chain);
c4093a6a 6628 }
d24317b4 6629
d9b3f62e 6630 if (is_tracepoint (b))
1042e4c0 6631 {
d9b3f62e
PA
6632 struct tracepoint *t = (struct tracepoint *) b;
6633
6634 if (!part_of_multiple && t->pass_count)
6635 {
6636 annotate_field (10);
112e8700
SM
6637 uiout->text ("\tpass count ");
6638 uiout->field_int ("pass", t->pass_count);
6639 uiout->text (" \n");
d9b3f62e 6640 }
f2a8bc8a
YQ
6641
6642 /* Don't display it when tracepoint or tracepoint location is
6643 pending. */
6644 if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6645 {
6646 annotate_field (11);
6647
112e8700
SM
6648 if (uiout->is_mi_like_p ())
6649 uiout->field_string ("installed",
f2a8bc8a
YQ
6650 loc->inserted ? "y" : "n");
6651 else
6652 {
6653 if (loc->inserted)
112e8700 6654 uiout->text ("\t");
f2a8bc8a 6655 else
112e8700
SM
6656 uiout->text ("\tnot ");
6657 uiout->text ("installed on target\n");
f2a8bc8a
YQ
6658 }
6659 }
1042e4c0
SS
6660 }
6661
112e8700 6662 if (uiout->is_mi_like_p () && !part_of_multiple)
d24317b4 6663 {
3a5c3e22
PA
6664 if (is_watchpoint (b))
6665 {
6666 struct watchpoint *w = (struct watchpoint *) b;
6667
112e8700 6668 uiout->field_string ("original-location", w->exp_string);
3a5c3e22 6669 }
f00aae0f 6670 else if (b->location != NULL
d28cd78a 6671 && event_location_to_string (b->location.get ()) != NULL)
112e8700 6672 uiout->field_string ("original-location",
d28cd78a 6673 event_location_to_string (b->location.get ()));
d24317b4 6674 }
c4093a6a 6675}
c5aa993b 6676
0d381245
VP
6677static void
6678print_one_breakpoint (struct breakpoint *b,
4a64f543 6679 struct bp_location **last_loc,
6c95b8df 6680 int allflag)
0d381245 6681{
8d3788bd 6682 struct cleanup *bkpt_chain;
79a45e25 6683 struct ui_out *uiout = current_uiout;
8d3788bd
VP
6684
6685 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
6686
12c5a436 6687 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
8d3788bd 6688 do_cleanups (bkpt_chain);
0d381245
VP
6689
6690 /* If this breakpoint has custom print function,
6691 it's already printed. Otherwise, print individual
6692 locations, if any. */
6693 if (b->ops == NULL || b->ops->print_one == NULL)
6694 {
4a64f543
MS
6695 /* If breakpoint has a single location that is disabled, we
6696 print it as if it had several locations, since otherwise it's
6697 hard to represent "breakpoint enabled, location disabled"
6698 situation.
6699
6700 Note that while hardware watchpoints have several locations
a3be7890 6701 internally, that's not a property exposed to user. */
0d381245 6702 if (b->loc
a5606eee 6703 && !is_hardware_watchpoint (b)
8d3788bd 6704 && (b->loc->next || !b->loc->enabled))
0d381245
VP
6705 {
6706 struct bp_location *loc;
6707 int n = 1;
8d3788bd 6708
0d381245 6709 for (loc = b->loc; loc; loc = loc->next, ++n)
8d3788bd
VP
6710 {
6711 struct cleanup *inner2 =
6712 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
6713 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6714 do_cleanups (inner2);
6715 }
0d381245
VP
6716 }
6717 }
6718}
6719
a6d9a66e
UW
6720static int
6721breakpoint_address_bits (struct breakpoint *b)
6722{
6723 int print_address_bits = 0;
6724 struct bp_location *loc;
6725
c6d81124
PA
6726 /* Software watchpoints that aren't watching memory don't have an
6727 address to print. */
6728 if (is_no_memory_software_watchpoint (b))
6729 return 0;
6730
a6d9a66e
UW
6731 for (loc = b->loc; loc; loc = loc->next)
6732 {
c7437ca6
PA
6733 int addr_bit;
6734
c7437ca6 6735 addr_bit = gdbarch_addr_bit (loc->gdbarch);
a6d9a66e
UW
6736 if (addr_bit > print_address_bits)
6737 print_address_bits = addr_bit;
6738 }
6739
6740 return print_address_bits;
6741}
0d381245 6742
c4093a6a
JM
6743struct captured_breakpoint_query_args
6744 {
6745 int bnum;
6746 };
c5aa993b 6747
c4093a6a 6748static int
2b65245e 6749do_captured_breakpoint_query (struct ui_out *uiout, void *data)
c4093a6a 6750{
9a3c8263
SM
6751 struct captured_breakpoint_query_args *args
6752 = (struct captured_breakpoint_query_args *) data;
52f0bd74 6753 struct breakpoint *b;
a6d9a66e 6754 struct bp_location *dummy_loc = NULL;
cc59ec59 6755
c4093a6a
JM
6756 ALL_BREAKPOINTS (b)
6757 {
6758 if (args->bnum == b->number)
c5aa993b 6759 {
12c5a436 6760 print_one_breakpoint (b, &dummy_loc, 0);
c4093a6a 6761 return GDB_RC_OK;
c5aa993b 6762 }
c4093a6a
JM
6763 }
6764 return GDB_RC_NONE;
6765}
c5aa993b 6766
c4093a6a 6767enum gdb_rc
4a64f543
MS
6768gdb_breakpoint_query (struct ui_out *uiout, int bnum,
6769 char **error_message)
c4093a6a
JM
6770{
6771 struct captured_breakpoint_query_args args;
cc59ec59 6772
c4093a6a
JM
6773 args.bnum = bnum;
6774 /* For the moment we don't trust print_one_breakpoint() to not throw
4a64f543 6775 an error. */
b0b13bb4
DJ
6776 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
6777 error_message, RETURN_MASK_ALL) < 0)
6778 return GDB_RC_FAIL;
6779 else
6780 return GDB_RC_OK;
c4093a6a 6781}
c5aa993b 6782
09d682a4
TT
6783/* Return true if this breakpoint was set by the user, false if it is
6784 internal or momentary. */
6785
6786int
6787user_breakpoint_p (struct breakpoint *b)
6788{
46c6471b 6789 return b->number > 0;
09d682a4
TT
6790}
6791
93daf339
TT
6792/* See breakpoint.h. */
6793
6794int
6795pending_breakpoint_p (struct breakpoint *b)
6796{
6797 return b->loc == NULL;
6798}
6799
7f3b0473 6800/* Print information on user settable breakpoint (watchpoint, etc)
d77f58be
SS
6801 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6802 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6803 FILTER is non-NULL, call it on each breakpoint and only include the
6804 ones for which it returns non-zero. Return the total number of
6805 breakpoints listed. */
c906108c 6806
d77f58be 6807static int
e5a67952 6808breakpoint_1 (char *args, int allflag,
4a64f543 6809 int (*filter) (const struct breakpoint *))
c4093a6a 6810{
52f0bd74 6811 struct breakpoint *b;
a6d9a66e 6812 struct bp_location *last_loc = NULL;
7f3b0473 6813 int nr_printable_breakpoints;
3b31d625 6814 struct cleanup *bkpttbl_chain;
79a45b7d 6815 struct value_print_options opts;
a6d9a66e 6816 int print_address_bits = 0;
269b11a2 6817 int print_type_col_width = 14;
79a45e25 6818 struct ui_out *uiout = current_uiout;
269b11a2 6819
79a45b7d
TT
6820 get_user_print_options (&opts);
6821
4a64f543
MS
6822 /* Compute the number of rows in the table, as well as the size
6823 required for address fields. */
7f3b0473
AC
6824 nr_printable_breakpoints = 0;
6825 ALL_BREAKPOINTS (b)
e5a67952
MS
6826 {
6827 /* If we have a filter, only list the breakpoints it accepts. */
6828 if (filter && !filter (b))
6829 continue;
6830
6831 /* If we have an "args" string, it is a list of breakpoints to
6832 accept. Skip the others. */
6833 if (args != NULL && *args != '\0')
6834 {
6835 if (allflag && parse_and_eval_long (args) != b->number)
6836 continue;
6837 if (!allflag && !number_is_in_list (args, b->number))
6838 continue;
6839 }
269b11a2 6840
e5a67952
MS
6841 if (allflag || user_breakpoint_p (b))
6842 {
6843 int addr_bit, type_len;
a6d9a66e 6844
e5a67952
MS
6845 addr_bit = breakpoint_address_bits (b);
6846 if (addr_bit > print_address_bits)
6847 print_address_bits = addr_bit;
269b11a2 6848
e5a67952
MS
6849 type_len = strlen (bptype_string (b->type));
6850 if (type_len > print_type_col_width)
6851 print_type_col_width = type_len;
6852
6853 nr_printable_breakpoints++;
6854 }
6855 }
7f3b0473 6856
79a45b7d 6857 if (opts.addressprint)
3b31d625 6858 bkpttbl_chain
3e43a32a
MS
6859 = make_cleanup_ui_out_table_begin_end (uiout, 6,
6860 nr_printable_breakpoints,
3b31d625 6861 "BreakpointTable");
8b93c638 6862 else
3b31d625 6863 bkpttbl_chain
3e43a32a
MS
6864 = make_cleanup_ui_out_table_begin_end (uiout, 5,
6865 nr_printable_breakpoints,
3b31d625 6866 "BreakpointTable");
8b93c638 6867
7f3b0473 6868 if (nr_printable_breakpoints > 0)
d7faa9e7
AC
6869 annotate_breakpoints_headers ();
6870 if (nr_printable_breakpoints > 0)
6871 annotate_field (0);
112e8700 6872 uiout->table_header (7, ui_left, "number", "Num"); /* 1 */
d7faa9e7
AC
6873 if (nr_printable_breakpoints > 0)
6874 annotate_field (1);
112e8700 6875 uiout->table_header (print_type_col_width, ui_left, "type", "Type"); /* 2 */
d7faa9e7
AC
6876 if (nr_printable_breakpoints > 0)
6877 annotate_field (2);
112e8700 6878 uiout->table_header (4, ui_left, "disp", "Disp"); /* 3 */
d7faa9e7
AC
6879 if (nr_printable_breakpoints > 0)
6880 annotate_field (3);
112e8700 6881 uiout->table_header (3, ui_left, "enabled", "Enb"); /* 4 */
79a45b7d 6882 if (opts.addressprint)
e5a67952
MS
6883 {
6884 if (nr_printable_breakpoints > 0)
6885 annotate_field (4);
6886 if (print_address_bits <= 32)
112e8700 6887 uiout->table_header (10, ui_left, "addr", "Address"); /* 5 */
e5a67952 6888 else
112e8700 6889 uiout->table_header (18, ui_left, "addr", "Address"); /* 5 */
e5a67952 6890 }
d7faa9e7
AC
6891 if (nr_printable_breakpoints > 0)
6892 annotate_field (5);
112e8700
SM
6893 uiout->table_header (40, ui_noalign, "what", "What"); /* 6 */
6894 uiout->table_body ();
d7faa9e7
AC
6895 if (nr_printable_breakpoints > 0)
6896 annotate_breakpoints_table ();
7f3b0473 6897
c4093a6a 6898 ALL_BREAKPOINTS (b)
e5a67952
MS
6899 {
6900 QUIT;
6901 /* If we have a filter, only list the breakpoints it accepts. */
6902 if (filter && !filter (b))
6903 continue;
6904
6905 /* If we have an "args" string, it is a list of breakpoints to
6906 accept. Skip the others. */
6907
6908 if (args != NULL && *args != '\0')
6909 {
6910 if (allflag) /* maintenance info breakpoint */
6911 {
6912 if (parse_and_eval_long (args) != b->number)
6913 continue;
6914 }
6915 else /* all others */
6916 {
6917 if (!number_is_in_list (args, b->number))
6918 continue;
6919 }
6920 }
6921 /* We only print out user settable breakpoints unless the
6922 allflag is set. */
6923 if (allflag || user_breakpoint_p (b))
12c5a436 6924 print_one_breakpoint (b, &last_loc, allflag);
e5a67952
MS
6925 }
6926
3b31d625 6927 do_cleanups (bkpttbl_chain);
698384cd 6928
7f3b0473 6929 if (nr_printable_breakpoints == 0)
c906108c 6930 {
4a64f543
MS
6931 /* If there's a filter, let the caller decide how to report
6932 empty list. */
d77f58be
SS
6933 if (!filter)
6934 {
e5a67952 6935 if (args == NULL || *args == '\0')
112e8700 6936 uiout->message ("No breakpoints or watchpoints.\n");
d77f58be 6937 else
112e8700 6938 uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
e5a67952 6939 args);
d77f58be 6940 }
c906108c
SS
6941 }
6942 else
c4093a6a 6943 {
a6d9a66e
UW
6944 if (last_loc && !server_command)
6945 set_next_address (last_loc->gdbarch, last_loc->address);
c4093a6a 6946 }
c906108c 6947
4a64f543 6948 /* FIXME? Should this be moved up so that it is only called when
c4093a6a 6949 there have been breakpoints? */
c906108c 6950 annotate_breakpoints_table_end ();
d77f58be
SS
6951
6952 return nr_printable_breakpoints;
c906108c
SS
6953}
6954
ad443146
SS
6955/* Display the value of default-collect in a way that is generally
6956 compatible with the breakpoint list. */
6957
6958static void
6959default_collect_info (void)
6960{
79a45e25
PA
6961 struct ui_out *uiout = current_uiout;
6962
ad443146
SS
6963 /* If it has no value (which is frequently the case), say nothing; a
6964 message like "No default-collect." gets in user's face when it's
6965 not wanted. */
6966 if (!*default_collect)
6967 return;
6968
6969 /* The following phrase lines up nicely with per-tracepoint collect
6970 actions. */
112e8700
SM
6971 uiout->text ("default collect ");
6972 uiout->field_string ("default-collect", default_collect);
6973 uiout->text (" \n");
ad443146
SS
6974}
6975
c906108c 6976static void
e5a67952 6977breakpoints_info (char *args, int from_tty)
c906108c 6978{
e5a67952 6979 breakpoint_1 (args, 0, NULL);
ad443146
SS
6980
6981 default_collect_info ();
d77f58be
SS
6982}
6983
6984static void
e5a67952 6985watchpoints_info (char *args, int from_tty)
d77f58be 6986{
e5a67952 6987 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
79a45e25 6988 struct ui_out *uiout = current_uiout;
d77f58be
SS
6989
6990 if (num_printed == 0)
6991 {
e5a67952 6992 if (args == NULL || *args == '\0')
112e8700 6993 uiout->message ("No watchpoints.\n");
d77f58be 6994 else
112e8700 6995 uiout->message ("No watchpoint matching '%s'.\n", args);
d77f58be 6996 }
c906108c
SS
6997}
6998
7a292a7a 6999static void
e5a67952 7000maintenance_info_breakpoints (char *args, int from_tty)
c906108c 7001{
e5a67952 7002 breakpoint_1 (args, 1, NULL);
ad443146
SS
7003
7004 default_collect_info ();
c906108c
SS
7005}
7006
0d381245 7007static int
714835d5 7008breakpoint_has_pc (struct breakpoint *b,
6c95b8df 7009 struct program_space *pspace,
714835d5 7010 CORE_ADDR pc, struct obj_section *section)
0d381245
VP
7011{
7012 struct bp_location *bl = b->loc;
cc59ec59 7013
0d381245
VP
7014 for (; bl; bl = bl->next)
7015 {
6c95b8df
PA
7016 if (bl->pspace == pspace
7017 && bl->address == pc
0d381245
VP
7018 && (!overlay_debugging || bl->section == section))
7019 return 1;
7020 }
7021 return 0;
7022}
7023
672f9b60 7024/* Print a message describing any user-breakpoints set at PC. This
6c95b8df
PA
7025 concerns with logical breakpoints, so we match program spaces, not
7026 address spaces. */
c906108c
SS
7027
7028static void
6c95b8df
PA
7029describe_other_breakpoints (struct gdbarch *gdbarch,
7030 struct program_space *pspace, CORE_ADDR pc,
5af949e3 7031 struct obj_section *section, int thread)
c906108c 7032{
52f0bd74
AC
7033 int others = 0;
7034 struct breakpoint *b;
c906108c
SS
7035
7036 ALL_BREAKPOINTS (b)
672f9b60
KP
7037 others += (user_breakpoint_p (b)
7038 && breakpoint_has_pc (b, pspace, pc, section));
c906108c
SS
7039 if (others > 0)
7040 {
a3f17187
AC
7041 if (others == 1)
7042 printf_filtered (_("Note: breakpoint "));
7043 else /* if (others == ???) */
7044 printf_filtered (_("Note: breakpoints "));
c906108c 7045 ALL_BREAKPOINTS (b)
672f9b60 7046 if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
0d381245
VP
7047 {
7048 others--;
7049 printf_filtered ("%d", b->number);
7050 if (b->thread == -1 && thread != -1)
7051 printf_filtered (" (all threads)");
7052 else if (b->thread != -1)
7053 printf_filtered (" (thread %d)", b->thread);
7054 printf_filtered ("%s%s ",
059fb39f 7055 ((b->enable_state == bp_disabled
f8eba3c6 7056 || b->enable_state == bp_call_disabled)
0d381245 7057 ? " (disabled)"
0d381245
VP
7058 : ""),
7059 (others > 1) ? ","
7060 : ((others == 1) ? " and" : ""));
7061 }
a3f17187 7062 printf_filtered (_("also set at pc "));
5af949e3 7063 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
c906108c
SS
7064 printf_filtered (".\n");
7065 }
7066}
7067\f
c906108c 7068
e4f237da 7069/* Return true iff it is meaningful to use the address member of
244558af
LM
7070 BPT locations. For some breakpoint types, the locations' address members
7071 are irrelevant and it makes no sense to attempt to compare them to other
7072 addresses (or use them for any other purpose either).
e4f237da 7073
4a64f543 7074 More specifically, each of the following breakpoint types will
244558af 7075 always have a zero valued location address and we don't want to mark
4a64f543 7076 breakpoints of any of these types to be a duplicate of an actual
244558af 7077 breakpoint location at address zero:
e4f237da
KB
7078
7079 bp_watchpoint
2d134ed3
PA
7080 bp_catchpoint
7081
7082*/
e4f237da
KB
7083
7084static int
7085breakpoint_address_is_meaningful (struct breakpoint *bpt)
7086{
7087 enum bptype type = bpt->type;
7088
2d134ed3
PA
7089 return (type != bp_watchpoint && type != bp_catchpoint);
7090}
7091
7092/* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
7093 true if LOC1 and LOC2 represent the same watchpoint location. */
7094
7095static int
4a64f543
MS
7096watchpoint_locations_match (struct bp_location *loc1,
7097 struct bp_location *loc2)
2d134ed3 7098{
3a5c3e22
PA
7099 struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
7100 struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
7101
7102 /* Both of them must exist. */
7103 gdb_assert (w1 != NULL);
7104 gdb_assert (w2 != NULL);
2bdf28a0 7105
4a64f543
MS
7106 /* If the target can evaluate the condition expression in hardware,
7107 then we we need to insert both watchpoints even if they are at
7108 the same place. Otherwise the watchpoint will only trigger when
7109 the condition of whichever watchpoint was inserted evaluates to
7110 true, not giving a chance for GDB to check the condition of the
7111 other watchpoint. */
3a5c3e22 7112 if ((w1->cond_exp
4a64f543
MS
7113 && target_can_accel_watchpoint_condition (loc1->address,
7114 loc1->length,
0cf6dd15 7115 loc1->watchpoint_type,
4d01a485 7116 w1->cond_exp.get ()))
3a5c3e22 7117 || (w2->cond_exp
4a64f543
MS
7118 && target_can_accel_watchpoint_condition (loc2->address,
7119 loc2->length,
0cf6dd15 7120 loc2->watchpoint_type,
4d01a485 7121 w2->cond_exp.get ())))
0cf6dd15
TJB
7122 return 0;
7123
85d721b8
PA
7124 /* Note that this checks the owner's type, not the location's. In
7125 case the target does not support read watchpoints, but does
7126 support access watchpoints, we'll have bp_read_watchpoint
7127 watchpoints with hw_access locations. Those should be considered
7128 duplicates of hw_read locations. The hw_read locations will
7129 become hw_access locations later. */
2d134ed3
PA
7130 return (loc1->owner->type == loc2->owner->type
7131 && loc1->pspace->aspace == loc2->pspace->aspace
7132 && loc1->address == loc2->address
7133 && loc1->length == loc2->length);
e4f237da
KB
7134}
7135
31e77af2 7136/* See breakpoint.h. */
6c95b8df 7137
31e77af2 7138int
6c95b8df
PA
7139breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
7140 struct address_space *aspace2, CORE_ADDR addr2)
7141{
f5656ead 7142 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6c95b8df
PA
7143 || aspace1 == aspace2)
7144 && addr1 == addr2);
7145}
7146
f1310107
TJB
7147/* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7148 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7149 matches ASPACE2. On targets that have global breakpoints, the address
7150 space doesn't really matter. */
7151
7152static int
7153breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
7154 int len1, struct address_space *aspace2,
7155 CORE_ADDR addr2)
7156{
f5656ead 7157 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
f1310107
TJB
7158 || aspace1 == aspace2)
7159 && addr2 >= addr1 && addr2 < addr1 + len1);
7160}
7161
7162/* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7163 a ranged breakpoint. In most targets, a match happens only if ASPACE
7164 matches the breakpoint's address space. On targets that have global
7165 breakpoints, the address space doesn't really matter. */
7166
7167static int
7168breakpoint_location_address_match (struct bp_location *bl,
7169 struct address_space *aspace,
7170 CORE_ADDR addr)
7171{
7172 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
7173 aspace, addr)
7174 || (bl->length
7175 && breakpoint_address_match_range (bl->pspace->aspace,
7176 bl->address, bl->length,
7177 aspace, addr)));
7178}
7179
d35ae833
PA
7180/* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7181 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7182 match happens only if ASPACE matches the breakpoint's address
7183 space. On targets that have global breakpoints, the address space
7184 doesn't really matter. */
7185
7186static int
7187breakpoint_location_address_range_overlap (struct bp_location *bl,
7188 struct address_space *aspace,
7189 CORE_ADDR addr, int len)
7190{
7191 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7192 || bl->pspace->aspace == aspace)
7193 {
7194 int bl_len = bl->length != 0 ? bl->length : 1;
7195
7196 if (mem_ranges_overlap (addr, len, bl->address, bl_len))
7197 return 1;
7198 }
7199 return 0;
7200}
7201
1e4d1764
YQ
7202/* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7203 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7204 true, otherwise returns false. */
7205
7206static int
7207tracepoint_locations_match (struct bp_location *loc1,
7208 struct bp_location *loc2)
7209{
7210 if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
7211 /* Since tracepoint locations are never duplicated with others', tracepoint
7212 locations at the same address of different tracepoints are regarded as
7213 different locations. */
7214 return (loc1->address == loc2->address && loc1->owner == loc2->owner);
7215 else
7216 return 0;
7217}
7218
2d134ed3
PA
7219/* Assuming LOC1 and LOC2's types' have meaningful target addresses
7220 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7221 represent the same location. */
7222
7223static int
4a64f543
MS
7224breakpoint_locations_match (struct bp_location *loc1,
7225 struct bp_location *loc2)
2d134ed3 7226{
2bdf28a0
JK
7227 int hw_point1, hw_point2;
7228
7229 /* Both of them must not be in moribund_locations. */
7230 gdb_assert (loc1->owner != NULL);
7231 gdb_assert (loc2->owner != NULL);
7232
7233 hw_point1 = is_hardware_watchpoint (loc1->owner);
7234 hw_point2 = is_hardware_watchpoint (loc2->owner);
2d134ed3
PA
7235
7236 if (hw_point1 != hw_point2)
7237 return 0;
7238 else if (hw_point1)
7239 return watchpoint_locations_match (loc1, loc2);
1e4d1764
YQ
7240 else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
7241 return tracepoint_locations_match (loc1, loc2);
2d134ed3 7242 else
f1310107
TJB
7243 /* We compare bp_location.length in order to cover ranged breakpoints. */
7244 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
7245 loc2->pspace->aspace, loc2->address)
7246 && loc1->length == loc2->length);
2d134ed3
PA
7247}
7248
76897487
KB
7249static void
7250breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
7251 int bnum, int have_bnum)
7252{
f63fbe86
MS
7253 /* The longest string possibly returned by hex_string_custom
7254 is 50 chars. These must be at least that big for safety. */
7255 char astr1[64];
7256 char astr2[64];
76897487 7257
bb599908
PH
7258 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
7259 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
76897487 7260 if (have_bnum)
8a3fe4f8 7261 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
76897487
KB
7262 bnum, astr1, astr2);
7263 else
8a3fe4f8 7264 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
76897487
KB
7265}
7266
4a64f543
MS
7267/* Adjust a breakpoint's address to account for architectural
7268 constraints on breakpoint placement. Return the adjusted address.
7269 Note: Very few targets require this kind of adjustment. For most
7270 targets, this function is simply the identity function. */
76897487
KB
7271
7272static CORE_ADDR
a6d9a66e
UW
7273adjust_breakpoint_address (struct gdbarch *gdbarch,
7274 CORE_ADDR bpaddr, enum bptype bptype)
76897487 7275{
a6d9a66e 7276 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
76897487
KB
7277 {
7278 /* Very few targets need any kind of breakpoint adjustment. */
7279 return bpaddr;
7280 }
88f7da05
KB
7281 else if (bptype == bp_watchpoint
7282 || bptype == bp_hardware_watchpoint
7283 || bptype == bp_read_watchpoint
7284 || bptype == bp_access_watchpoint
fe798b75 7285 || bptype == bp_catchpoint)
88f7da05
KB
7286 {
7287 /* Watchpoints and the various bp_catch_* eventpoints should not
7288 have their addresses modified. */
7289 return bpaddr;
7290 }
7c16b83e
PA
7291 else if (bptype == bp_single_step)
7292 {
7293 /* Single-step breakpoints should not have their addresses
7294 modified. If there's any architectural constrain that
7295 applies to this address, then it should have already been
7296 taken into account when the breakpoint was created in the
7297 first place. If we didn't do this, stepping through e.g.,
7298 Thumb-2 IT blocks would break. */
7299 return bpaddr;
7300 }
76897487
KB
7301 else
7302 {
7303 CORE_ADDR adjusted_bpaddr;
7304
7305 /* Some targets have architectural constraints on the placement
7306 of breakpoint instructions. Obtain the adjusted address. */
a6d9a66e 7307 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
76897487
KB
7308
7309 /* An adjusted breakpoint address can significantly alter
7310 a user's expectations. Print a warning if an adjustment
7311 is required. */
7312 if (adjusted_bpaddr != bpaddr)
7313 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
7314
7315 return adjusted_bpaddr;
7316 }
7317}
7318
28010a5d
PA
7319void
7320init_bp_location (struct bp_location *loc, const struct bp_location_ops *ops,
7321 struct breakpoint *owner)
7cc221ef 7322{
7cc221ef
DJ
7323 memset (loc, 0, sizeof (*loc));
7324
348d480f
PA
7325 gdb_assert (ops != NULL);
7326
28010a5d
PA
7327 loc->ops = ops;
7328 loc->owner = owner;
b775012e 7329 loc->cond_bytecode = NULL;
0d381245
VP
7330 loc->shlib_disabled = 0;
7331 loc->enabled = 1;
e049a4b5 7332
28010a5d 7333 switch (owner->type)
e049a4b5
DJ
7334 {
7335 case bp_breakpoint:
7c16b83e 7336 case bp_single_step:
e049a4b5
DJ
7337 case bp_until:
7338 case bp_finish:
7339 case bp_longjmp:
7340 case bp_longjmp_resume:
e2e4d78b 7341 case bp_longjmp_call_dummy:
186c406b
TT
7342 case bp_exception:
7343 case bp_exception_resume:
e049a4b5 7344 case bp_step_resume:
2c03e5be 7345 case bp_hp_step_resume:
e049a4b5
DJ
7346 case bp_watchpoint_scope:
7347 case bp_call_dummy:
aa7d318d 7348 case bp_std_terminate:
e049a4b5
DJ
7349 case bp_shlib_event:
7350 case bp_thread_event:
7351 case bp_overlay_event:
4efc6507 7352 case bp_jit_event:
0fd8e87f 7353 case bp_longjmp_master:
aa7d318d 7354 case bp_std_terminate_master:
186c406b 7355 case bp_exception_master:
0e30163f
JK
7356 case bp_gnu_ifunc_resolver:
7357 case bp_gnu_ifunc_resolver_return:
e7e0cddf 7358 case bp_dprintf:
e049a4b5 7359 loc->loc_type = bp_loc_software_breakpoint;
b775012e 7360 mark_breakpoint_location_modified (loc);
e049a4b5
DJ
7361 break;
7362 case bp_hardware_breakpoint:
7363 loc->loc_type = bp_loc_hardware_breakpoint;
b775012e 7364 mark_breakpoint_location_modified (loc);
e049a4b5
DJ
7365 break;
7366 case bp_hardware_watchpoint:
7367 case bp_read_watchpoint:
7368 case bp_access_watchpoint:
7369 loc->loc_type = bp_loc_hardware_watchpoint;
7370 break;
7371 case bp_watchpoint:
ce78b96d 7372 case bp_catchpoint:
15c3d785
PA
7373 case bp_tracepoint:
7374 case bp_fast_tracepoint:
0fb4aa4b 7375 case bp_static_tracepoint:
e049a4b5
DJ
7376 loc->loc_type = bp_loc_other;
7377 break;
7378 default:
e2e0b3e5 7379 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
e049a4b5
DJ
7380 }
7381
f431efe5 7382 loc->refc = 1;
28010a5d
PA
7383}
7384
7385/* Allocate a struct bp_location. */
7386
7387static struct bp_location *
7388allocate_bp_location (struct breakpoint *bpt)
7389{
348d480f
PA
7390 return bpt->ops->allocate_location (bpt);
7391}
7cc221ef 7392
f431efe5
PA
7393static void
7394free_bp_location (struct bp_location *loc)
fe3f5fa8 7395{
348d480f 7396 loc->ops->dtor (loc);
4d01a485 7397 delete loc;
fe3f5fa8
VP
7398}
7399
f431efe5
PA
7400/* Increment reference count. */
7401
7402static void
7403incref_bp_location (struct bp_location *bl)
7404{
7405 ++bl->refc;
7406}
7407
7408/* Decrement reference count. If the reference count reaches 0,
7409 destroy the bp_location. Sets *BLP to NULL. */
7410
7411static void
7412decref_bp_location (struct bp_location **blp)
7413{
0807b50c
PA
7414 gdb_assert ((*blp)->refc > 0);
7415
f431efe5
PA
7416 if (--(*blp)->refc == 0)
7417 free_bp_location (*blp);
7418 *blp = NULL;
7419}
7420
346774a9 7421/* Add breakpoint B at the end of the global breakpoint chain. */
c906108c 7422
346774a9
PA
7423static void
7424add_to_breakpoint_chain (struct breakpoint *b)
c906108c 7425{
346774a9 7426 struct breakpoint *b1;
c906108c 7427
346774a9
PA
7428 /* Add this breakpoint to the end of the chain so that a list of
7429 breakpoints will come out in order of increasing numbers. */
7430
7431 b1 = breakpoint_chain;
7432 if (b1 == 0)
7433 breakpoint_chain = b;
7434 else
7435 {
7436 while (b1->next)
7437 b1 = b1->next;
7438 b1->next = b;
7439 }
7440}
7441
7442/* Initializes breakpoint B with type BPTYPE and no locations yet. */
7443
7444static void
7445init_raw_breakpoint_without_location (struct breakpoint *b,
7446 struct gdbarch *gdbarch,
28010a5d 7447 enum bptype bptype,
c0a91b2b 7448 const struct breakpoint_ops *ops)
346774a9 7449{
c906108c 7450 memset (b, 0, sizeof (*b));
2219d63c 7451
348d480f
PA
7452 gdb_assert (ops != NULL);
7453
28010a5d 7454 b->ops = ops;
4d28f7a8 7455 b->type = bptype;
a6d9a66e 7456 b->gdbarch = gdbarch;
c906108c
SS
7457 b->language = current_language->la_language;
7458 b->input_radix = input_radix;
7459 b->thread = -1;
b5de0fa7 7460 b->enable_state = bp_enabled;
c906108c
SS
7461 b->next = 0;
7462 b->silent = 0;
7463 b->ignore_count = 0;
7464 b->commands = NULL;
818dd999 7465 b->frame_id = null_frame_id;
0d381245 7466 b->condition_not_parsed = 0;
84f4c1fe 7467 b->py_bp_object = NULL;
d0fb5eae 7468 b->related_breakpoint = b;
f00aae0f 7469 b->location = NULL;
346774a9
PA
7470}
7471
7472/* Helper to set_raw_breakpoint below. Creates a breakpoint
7473 that has type BPTYPE and has no locations as yet. */
346774a9
PA
7474
7475static struct breakpoint *
7476set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
348d480f 7477 enum bptype bptype,
c0a91b2b 7478 const struct breakpoint_ops *ops)
346774a9 7479{
4d01a485 7480 struct breakpoint *b = new breakpoint ();
346774a9 7481
348d480f 7482 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
c56053d2 7483 add_to_breakpoint_chain (b);
0d381245
VP
7484 return b;
7485}
7486
0e30163f
JK
7487/* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7488 resolutions should be made as the user specified the location explicitly
7489 enough. */
7490
0d381245 7491static void
0e30163f 7492set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
0d381245 7493{
2bdf28a0
JK
7494 gdb_assert (loc->owner != NULL);
7495
0d381245 7496 if (loc->owner->type == bp_breakpoint
1042e4c0 7497 || loc->owner->type == bp_hardware_breakpoint
d77f58be 7498 || is_tracepoint (loc->owner))
0d381245 7499 {
0e30163f 7500 int is_gnu_ifunc;
2c02bd72 7501 const char *function_name;
6a3a010b 7502 CORE_ADDR func_addr;
0e30163f 7503
2c02bd72 7504 find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
6a3a010b 7505 &func_addr, NULL, &is_gnu_ifunc);
0e30163f
JK
7506
7507 if (is_gnu_ifunc && !explicit_loc)
7508 {
7509 struct breakpoint *b = loc->owner;
7510
7511 gdb_assert (loc->pspace == current_program_space);
2c02bd72 7512 if (gnu_ifunc_resolve_name (function_name,
0e30163f
JK
7513 &loc->requested_address))
7514 {
7515 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7516 loc->address = adjust_breakpoint_address (loc->gdbarch,
7517 loc->requested_address,
7518 b->type);
7519 }
7520 else if (b->type == bp_breakpoint && b->loc == loc
7521 && loc->next == NULL && b->related_breakpoint == b)
7522 {
7523 /* Create only the whole new breakpoint of this type but do not
7524 mess more complicated breakpoints with multiple locations. */
7525 b->type = bp_gnu_ifunc_resolver;
6a3a010b
MR
7526 /* Remember the resolver's address for use by the return
7527 breakpoint. */
7528 loc->related_address = func_addr;
0e30163f
JK
7529 }
7530 }
7531
2c02bd72
DE
7532 if (function_name)
7533 loc->function_name = xstrdup (function_name);
0d381245
VP
7534 }
7535}
7536
a6d9a66e 7537/* Attempt to determine architecture of location identified by SAL. */
1bfeeb0f 7538struct gdbarch *
a6d9a66e
UW
7539get_sal_arch (struct symtab_and_line sal)
7540{
7541 if (sal.section)
7542 return get_objfile_arch (sal.section->objfile);
7543 if (sal.symtab)
eb822aa6 7544 return get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
a6d9a66e
UW
7545
7546 return NULL;
7547}
7548
346774a9
PA
7549/* Low level routine for partially initializing a breakpoint of type
7550 BPTYPE. The newly created breakpoint's address, section, source
c56053d2 7551 file name, and line number are provided by SAL.
0d381245
VP
7552
7553 It is expected that the caller will complete the initialization of
7554 the newly created breakpoint struct as well as output any status
c56053d2 7555 information regarding the creation of a new breakpoint. */
0d381245 7556
346774a9
PA
7557static void
7558init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
28010a5d 7559 struct symtab_and_line sal, enum bptype bptype,
c0a91b2b 7560 const struct breakpoint_ops *ops)
0d381245 7561{
28010a5d 7562 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
346774a9 7563
3742cc8b 7564 add_location_to_breakpoint (b, &sal);
0d381245 7565
6c95b8df
PA
7566 if (bptype != bp_catchpoint)
7567 gdb_assert (sal.pspace != NULL);
7568
f8eba3c6
TT
7569 /* Store the program space that was used to set the breakpoint,
7570 except for ordinary breakpoints, which are independent of the
7571 program space. */
7572 if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7573 b->pspace = sal.pspace;
346774a9 7574}
c906108c 7575
346774a9
PA
7576/* set_raw_breakpoint is a low level routine for allocating and
7577 partially initializing a breakpoint of type BPTYPE. The newly
7578 created breakpoint's address, section, source file name, and line
7579 number are provided by SAL. The newly created and partially
7580 initialized breakpoint is added to the breakpoint chain and
7581 is also returned as the value of this function.
7582
7583 It is expected that the caller will complete the initialization of
7584 the newly created breakpoint struct as well as output any status
7585 information regarding the creation of a new breakpoint. In
7586 particular, set_raw_breakpoint does NOT set the breakpoint
7587 number! Care should be taken to not allow an error to occur
7588 prior to completing the initialization of the breakpoint. If this
7589 should happen, a bogus breakpoint will be left on the chain. */
7590
7591struct breakpoint *
7592set_raw_breakpoint (struct gdbarch *gdbarch,
348d480f 7593 struct symtab_and_line sal, enum bptype bptype,
c0a91b2b 7594 const struct breakpoint_ops *ops)
346774a9 7595{
4d01a485 7596 struct breakpoint *b = new breakpoint ();
346774a9 7597
348d480f 7598 init_raw_breakpoint (b, gdbarch, sal, bptype, ops);
c56053d2 7599 add_to_breakpoint_chain (b);
c906108c
SS
7600 return b;
7601}
7602
53a5351d 7603/* Call this routine when stepping and nexting to enable a breakpoint
186c406b
TT
7604 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7605 initiated the operation. */
c906108c
SS
7606
7607void
186c406b 7608set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
c906108c 7609{
35df4500 7610 struct breakpoint *b, *b_tmp;
5d5658a1 7611 int thread = tp->global_num;
0fd8e87f
UW
7612
7613 /* To avoid having to rescan all objfile symbols at every step,
7614 we maintain a list of continually-inserted but always disabled
7615 longjmp "master" breakpoints. Here, we simply create momentary
7616 clones of those and enable them for the requested thread. */
35df4500 7617 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6c95b8df 7618 if (b->pspace == current_program_space
186c406b
TT
7619 && (b->type == bp_longjmp_master
7620 || b->type == bp_exception_master))
0fd8e87f 7621 {
06edf0c0
PA
7622 enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7623 struct breakpoint *clone;
cc59ec59 7624
e2e4d78b
JK
7625 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7626 after their removal. */
06edf0c0 7627 clone = momentary_breakpoint_from_master (b, type,
a1aa2221 7628 &longjmp_breakpoint_ops, 1);
0fd8e87f
UW
7629 clone->thread = thread;
7630 }
186c406b
TT
7631
7632 tp->initiating_frame = frame;
c906108c
SS
7633}
7634
611c83ae 7635/* Delete all longjmp breakpoints from THREAD. */
c906108c 7636void
611c83ae 7637delete_longjmp_breakpoint (int thread)
c906108c 7638{
35df4500 7639 struct breakpoint *b, *b_tmp;
c906108c 7640
35df4500 7641 ALL_BREAKPOINTS_SAFE (b, b_tmp)
186c406b 7642 if (b->type == bp_longjmp || b->type == bp_exception)
611c83ae
PA
7643 {
7644 if (b->thread == thread)
7645 delete_breakpoint (b);
7646 }
c906108c
SS
7647}
7648
f59f708a
PA
7649void
7650delete_longjmp_breakpoint_at_next_stop (int thread)
7651{
7652 struct breakpoint *b, *b_tmp;
7653
7654 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7655 if (b->type == bp_longjmp || b->type == bp_exception)
7656 {
7657 if (b->thread == thread)
7658 b->disposition = disp_del_at_next_stop;
7659 }
7660}
7661
e2e4d78b
JK
7662/* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7663 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7664 pointer to any of them. Return NULL if this system cannot place longjmp
7665 breakpoints. */
7666
7667struct breakpoint *
7668set_longjmp_breakpoint_for_call_dummy (void)
7669{
7670 struct breakpoint *b, *retval = NULL;
7671
7672 ALL_BREAKPOINTS (b)
7673 if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7674 {
7675 struct breakpoint *new_b;
7676
7677 new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
a1aa2221
LM
7678 &momentary_breakpoint_ops,
7679 1);
5d5658a1 7680 new_b->thread = ptid_to_global_thread_id (inferior_ptid);
e2e4d78b
JK
7681
7682 /* Link NEW_B into the chain of RETVAL breakpoints. */
7683
7684 gdb_assert (new_b->related_breakpoint == new_b);
7685 if (retval == NULL)
7686 retval = new_b;
7687 new_b->related_breakpoint = retval;
7688 while (retval->related_breakpoint != new_b->related_breakpoint)
7689 retval = retval->related_breakpoint;
7690 retval->related_breakpoint = new_b;
7691 }
7692
7693 return retval;
7694}
7695
7696/* Verify all existing dummy frames and their associated breakpoints for
b67a2c6f 7697 TP. Remove those which can no longer be found in the current frame
e2e4d78b
JK
7698 stack.
7699
7700 You should call this function only at places where it is safe to currently
7701 unwind the whole stack. Failed stack unwind would discard live dummy
7702 frames. */
7703
7704void
b67a2c6f 7705check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
e2e4d78b
JK
7706{
7707 struct breakpoint *b, *b_tmp;
7708
7709 ALL_BREAKPOINTS_SAFE (b, b_tmp)
5d5658a1 7710 if (b->type == bp_longjmp_call_dummy && b->thread == tp->global_num)
e2e4d78b
JK
7711 {
7712 struct breakpoint *dummy_b = b->related_breakpoint;
7713
7714 while (dummy_b != b && dummy_b->type != bp_call_dummy)
7715 dummy_b = dummy_b->related_breakpoint;
7716 if (dummy_b->type != bp_call_dummy
7717 || frame_find_by_id (dummy_b->frame_id) != NULL)
7718 continue;
7719
b67a2c6f 7720 dummy_frame_discard (dummy_b->frame_id, tp->ptid);
e2e4d78b
JK
7721
7722 while (b->related_breakpoint != b)
7723 {
7724 if (b_tmp == b->related_breakpoint)
7725 b_tmp = b->related_breakpoint->next;
7726 delete_breakpoint (b->related_breakpoint);
7727 }
7728 delete_breakpoint (b);
7729 }
7730}
7731
1900040c
MS
7732void
7733enable_overlay_breakpoints (void)
7734{
52f0bd74 7735 struct breakpoint *b;
1900040c
MS
7736
7737 ALL_BREAKPOINTS (b)
7738 if (b->type == bp_overlay_event)
7739 {
7740 b->enable_state = bp_enabled;
44702360 7741 update_global_location_list (UGLL_MAY_INSERT);
c02f5703 7742 overlay_events_enabled = 1;
1900040c
MS
7743 }
7744}
7745
7746void
7747disable_overlay_breakpoints (void)
7748{
52f0bd74 7749 struct breakpoint *b;
1900040c
MS
7750
7751 ALL_BREAKPOINTS (b)
7752 if (b->type == bp_overlay_event)
7753 {
7754 b->enable_state = bp_disabled;
44702360 7755 update_global_location_list (UGLL_DONT_INSERT);
c02f5703 7756 overlay_events_enabled = 0;
1900040c
MS
7757 }
7758}
7759
aa7d318d
TT
7760/* Set an active std::terminate breakpoint for each std::terminate
7761 master breakpoint. */
7762void
7763set_std_terminate_breakpoint (void)
7764{
35df4500 7765 struct breakpoint *b, *b_tmp;
aa7d318d 7766
35df4500 7767 ALL_BREAKPOINTS_SAFE (b, b_tmp)
aa7d318d
TT
7768 if (b->pspace == current_program_space
7769 && b->type == bp_std_terminate_master)
7770 {
06edf0c0 7771 momentary_breakpoint_from_master (b, bp_std_terminate,
a1aa2221 7772 &momentary_breakpoint_ops, 1);
aa7d318d
TT
7773 }
7774}
7775
7776/* Delete all the std::terminate breakpoints. */
7777void
7778delete_std_terminate_breakpoint (void)
7779{
35df4500 7780 struct breakpoint *b, *b_tmp;
aa7d318d 7781
35df4500 7782 ALL_BREAKPOINTS_SAFE (b, b_tmp)
aa7d318d
TT
7783 if (b->type == bp_std_terminate)
7784 delete_breakpoint (b);
7785}
7786
c4093a6a 7787struct breakpoint *
a6d9a66e 7788create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
c4093a6a
JM
7789{
7790 struct breakpoint *b;
c4093a6a 7791
06edf0c0
PA
7792 b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7793 &internal_breakpoint_ops);
7794
b5de0fa7 7795 b->enable_state = bp_enabled;
f00aae0f 7796 /* location has to be used or breakpoint_re_set will delete me. */
d28cd78a 7797 b->location = new_address_location (b->loc->address, NULL, 0);
c4093a6a 7798
44702360 7799 update_global_location_list_nothrow (UGLL_MAY_INSERT);
74960c60 7800
c4093a6a
JM
7801 return b;
7802}
7803
0101ce28
JJ
7804struct lang_and_radix
7805 {
7806 enum language lang;
7807 int radix;
7808 };
7809
4efc6507
DE
7810/* Create a breakpoint for JIT code registration and unregistration. */
7811
7812struct breakpoint *
7813create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7814{
2a7f3dff
PA
7815 return create_internal_breakpoint (gdbarch, address, bp_jit_event,
7816 &internal_breakpoint_ops);
4efc6507 7817}
0101ce28 7818
03673fc7
PP
7819/* Remove JIT code registration and unregistration breakpoint(s). */
7820
7821void
7822remove_jit_event_breakpoints (void)
7823{
7824 struct breakpoint *b, *b_tmp;
7825
7826 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7827 if (b->type == bp_jit_event
7828 && b->loc->pspace == current_program_space)
7829 delete_breakpoint (b);
7830}
7831
cae688ec
JJ
7832void
7833remove_solib_event_breakpoints (void)
7834{
35df4500 7835 struct breakpoint *b, *b_tmp;
cae688ec 7836
35df4500 7837 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6c95b8df
PA
7838 if (b->type == bp_shlib_event
7839 && b->loc->pspace == current_program_space)
cae688ec
JJ
7840 delete_breakpoint (b);
7841}
7842
f37f681c
PA
7843/* See breakpoint.h. */
7844
7845void
7846remove_solib_event_breakpoints_at_next_stop (void)
7847{
7848 struct breakpoint *b, *b_tmp;
7849
7850 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7851 if (b->type == bp_shlib_event
7852 && b->loc->pspace == current_program_space)
7853 b->disposition = disp_del_at_next_stop;
7854}
7855
04086b45
PA
7856/* Helper for create_solib_event_breakpoint /
7857 create_and_insert_solib_event_breakpoint. Allows specifying which
7858 INSERT_MODE to pass through to update_global_location_list. */
7859
7860static struct breakpoint *
7861create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
7862 enum ugll_insert_mode insert_mode)
cae688ec
JJ
7863{
7864 struct breakpoint *b;
7865
06edf0c0
PA
7866 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7867 &internal_breakpoint_ops);
04086b45 7868 update_global_location_list_nothrow (insert_mode);
cae688ec
JJ
7869 return b;
7870}
7871
04086b45
PA
7872struct breakpoint *
7873create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7874{
7875 return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
7876}
7877
f37f681c
PA
7878/* See breakpoint.h. */
7879
7880struct breakpoint *
7881create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7882{
7883 struct breakpoint *b;
7884
04086b45
PA
7885 /* Explicitly tell update_global_location_list to insert
7886 locations. */
7887 b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
f37f681c
PA
7888 if (!b->loc->inserted)
7889 {
7890 delete_breakpoint (b);
7891 return NULL;
7892 }
7893 return b;
7894}
7895
cae688ec
JJ
7896/* Disable any breakpoints that are on code in shared libraries. Only
7897 apply to enabled breakpoints, disabled ones can just stay disabled. */
7898
7899void
cb851954 7900disable_breakpoints_in_shlibs (void)
cae688ec 7901{
876fa593 7902 struct bp_location *loc, **locp_tmp;
cae688ec 7903
876fa593 7904 ALL_BP_LOCATIONS (loc, locp_tmp)
cae688ec 7905 {
2bdf28a0 7906 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
0d381245 7907 struct breakpoint *b = loc->owner;
2bdf28a0 7908
4a64f543
MS
7909 /* We apply the check to all breakpoints, including disabled for
7910 those with loc->duplicate set. This is so that when breakpoint
7911 becomes enabled, or the duplicate is removed, gdb will try to
7912 insert all breakpoints. If we don't set shlib_disabled here,
7913 we'll try to insert those breakpoints and fail. */
1042e4c0 7914 if (((b->type == bp_breakpoint)
508ccb1f 7915 || (b->type == bp_jit_event)
1042e4c0 7916 || (b->type == bp_hardware_breakpoint)
d77f58be 7917 || (is_tracepoint (b)))
6c95b8df 7918 && loc->pspace == current_program_space
0d381245 7919 && !loc->shlib_disabled
6c95b8df 7920 && solib_name_from_address (loc->pspace, loc->address)
a77053c2 7921 )
0d381245
VP
7922 {
7923 loc->shlib_disabled = 1;
7924 }
cae688ec
JJ
7925 }
7926}
7927
63644780
NB
7928/* Disable any breakpoints and tracepoints that are in SOLIB upon
7929 notification of unloaded_shlib. Only apply to enabled breakpoints,
7930 disabled ones can just stay disabled. */
84acb35a 7931
75149521 7932static void
84acb35a
JJ
7933disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7934{
876fa593 7935 struct bp_location *loc, **locp_tmp;
84acb35a
JJ
7936 int disabled_shlib_breaks = 0;
7937
876fa593 7938 ALL_BP_LOCATIONS (loc, locp_tmp)
84acb35a 7939 {
2bdf28a0 7940 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
0d381245 7941 struct breakpoint *b = loc->owner;
cc59ec59 7942
1e4d1764 7943 if (solib->pspace == loc->pspace
e2dd7057 7944 && !loc->shlib_disabled
1e4d1764
YQ
7945 && (((b->type == bp_breakpoint
7946 || b->type == bp_jit_event
7947 || b->type == bp_hardware_breakpoint)
7948 && (loc->loc_type == bp_loc_hardware_breakpoint
7949 || loc->loc_type == bp_loc_software_breakpoint))
7950 || is_tracepoint (b))
e2dd7057 7951 && solib_contains_address_p (solib, loc->address))
84acb35a 7952 {
e2dd7057
PP
7953 loc->shlib_disabled = 1;
7954 /* At this point, we cannot rely on remove_breakpoint
7955 succeeding so we must mark the breakpoint as not inserted
7956 to prevent future errors occurring in remove_breakpoints. */
7957 loc->inserted = 0;
8d3788bd
VP
7958
7959 /* This may cause duplicate notifications for the same breakpoint. */
7960 observer_notify_breakpoint_modified (b);
7961
e2dd7057
PP
7962 if (!disabled_shlib_breaks)
7963 {
7964 target_terminal_ours_for_output ();
3e43a32a
MS
7965 warning (_("Temporarily disabling breakpoints "
7966 "for unloaded shared library \"%s\""),
e2dd7057 7967 solib->so_name);
84acb35a 7968 }
e2dd7057 7969 disabled_shlib_breaks = 1;
84acb35a
JJ
7970 }
7971 }
84acb35a
JJ
7972}
7973
63644780
NB
7974/* Disable any breakpoints and tracepoints in OBJFILE upon
7975 notification of free_objfile. Only apply to enabled breakpoints,
7976 disabled ones can just stay disabled. */
7977
7978static void
7979disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7980{
7981 struct breakpoint *b;
7982
7983 if (objfile == NULL)
7984 return;
7985
d03de421
PA
7986 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7987 managed by the user with add-symbol-file/remove-symbol-file.
7988 Similarly to how breakpoints in shared libraries are handled in
7989 response to "nosharedlibrary", mark breakpoints in such modules
08351840
PA
7990 shlib_disabled so they end up uninserted on the next global
7991 location list update. Shared libraries not loaded by the user
7992 aren't handled here -- they're already handled in
7993 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7994 solib_unloaded observer. We skip objfiles that are not
d03de421
PA
7995 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7996 main objfile). */
7997 if ((objfile->flags & OBJF_SHARED) == 0
7998 || (objfile->flags & OBJF_USERLOADED) == 0)
63644780
NB
7999 return;
8000
8001 ALL_BREAKPOINTS (b)
8002 {
8003 struct bp_location *loc;
8004 int bp_modified = 0;
8005
8006 if (!is_breakpoint (b) && !is_tracepoint (b))
8007 continue;
8008
8009 for (loc = b->loc; loc != NULL; loc = loc->next)
8010 {
8011 CORE_ADDR loc_addr = loc->address;
8012
8013 if (loc->loc_type != bp_loc_hardware_breakpoint
8014 && loc->loc_type != bp_loc_software_breakpoint)
8015 continue;
8016
8017 if (loc->shlib_disabled != 0)
8018 continue;
8019
8020 if (objfile->pspace != loc->pspace)
8021 continue;
8022
8023 if (loc->loc_type != bp_loc_hardware_breakpoint
8024 && loc->loc_type != bp_loc_software_breakpoint)
8025 continue;
8026
8027 if (is_addr_in_objfile (loc_addr, objfile))
8028 {
8029 loc->shlib_disabled = 1;
08351840
PA
8030 /* At this point, we don't know whether the object was
8031 unmapped from the inferior or not, so leave the
8032 inserted flag alone. We'll handle failure to
8033 uninsert quietly, in case the object was indeed
8034 unmapped. */
63644780
NB
8035
8036 mark_breakpoint_location_modified (loc);
8037
8038 bp_modified = 1;
8039 }
8040 }
8041
8042 if (bp_modified)
8043 observer_notify_breakpoint_modified (b);
8044 }
8045}
8046
ce78b96d
JB
8047/* FORK & VFORK catchpoints. */
8048
e29a4733
PA
8049/* An instance of this type is used to represent a fork or vfork
8050 catchpoint. It includes a "struct breakpoint" as a kind of base
8051 class; users downcast to "struct breakpoint *" when needed. A
8052 breakpoint is really of this type iff its ops pointer points to
8053 CATCH_FORK_BREAKPOINT_OPS. */
8054
8055struct fork_catchpoint
8056{
8057 /* The base class. */
8058 struct breakpoint base;
8059
8060 /* Process id of a child process whose forking triggered this
8061 catchpoint. This field is only valid immediately after this
8062 catchpoint has triggered. */
8063 ptid_t forked_inferior_pid;
8064};
8065
4a64f543
MS
8066/* Implement the "insert" breakpoint_ops method for fork
8067 catchpoints. */
ce78b96d 8068
77b06cd7
TJB
8069static int
8070insert_catch_fork (struct bp_location *bl)
ce78b96d 8071{
dfd4cc63 8072 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid));
ce78b96d
JB
8073}
8074
4a64f543
MS
8075/* Implement the "remove" breakpoint_ops method for fork
8076 catchpoints. */
ce78b96d
JB
8077
8078static int
73971819 8079remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason)
ce78b96d 8080{
dfd4cc63 8081 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid));
ce78b96d
JB
8082}
8083
8084/* Implement the "breakpoint_hit" breakpoint_ops method for fork
8085 catchpoints. */
8086
8087static int
f1310107 8088breakpoint_hit_catch_fork (const struct bp_location *bl,
09ac7c10
TT
8089 struct address_space *aspace, CORE_ADDR bp_addr,
8090 const struct target_waitstatus *ws)
ce78b96d 8091{
e29a4733
PA
8092 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
8093
f90263c1
TT
8094 if (ws->kind != TARGET_WAITKIND_FORKED)
8095 return 0;
8096
8097 c->forked_inferior_pid = ws->value.related_pid;
8098 return 1;
ce78b96d
JB
8099}
8100
4a64f543
MS
8101/* Implement the "print_it" breakpoint_ops method for fork
8102 catchpoints. */
ce78b96d
JB
8103
8104static enum print_stop_action
348d480f 8105print_it_catch_fork (bpstat bs)
ce78b96d 8106{
36dfb11c 8107 struct ui_out *uiout = current_uiout;
348d480f
PA
8108 struct breakpoint *b = bs->breakpoint_at;
8109 struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
e29a4733 8110
ce78b96d 8111 annotate_catchpoint (b->number);
f303dbd6 8112 maybe_print_thread_hit_breakpoint (uiout);
36dfb11c 8113 if (b->disposition == disp_del)
112e8700 8114 uiout->text ("Temporary catchpoint ");
36dfb11c 8115 else
112e8700
SM
8116 uiout->text ("Catchpoint ");
8117 if (uiout->is_mi_like_p ())
36dfb11c 8118 {
112e8700
SM
8119 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
8120 uiout->field_string ("disp", bpdisp_text (b->disposition));
36dfb11c 8121 }
112e8700
SM
8122 uiout->field_int ("bkptno", b->number);
8123 uiout->text (" (forked process ");
8124 uiout->field_int ("newpid", ptid_get_pid (c->forked_inferior_pid));
8125 uiout->text ("), ");
ce78b96d
JB
8126 return PRINT_SRC_AND_LOC;
8127}
8128
4a64f543
MS
8129/* Implement the "print_one" breakpoint_ops method for fork
8130 catchpoints. */
ce78b96d
JB
8131
8132static void
a6d9a66e 8133print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
ce78b96d 8134{
e29a4733 8135 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
79a45b7d 8136 struct value_print_options opts;
79a45e25 8137 struct ui_out *uiout = current_uiout;
79a45b7d
TT
8138
8139 get_user_print_options (&opts);
8140
4a64f543
MS
8141 /* Field 4, the address, is omitted (which makes the columns not
8142 line up too nicely with the headers, but the effect is relatively
8143 readable). */
79a45b7d 8144 if (opts.addressprint)
112e8700 8145 uiout->field_skip ("addr");
ce78b96d 8146 annotate_field (5);
112e8700 8147 uiout->text ("fork");
e29a4733 8148 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
ce78b96d 8149 {
112e8700
SM
8150 uiout->text (", process ");
8151 uiout->field_int ("what", ptid_get_pid (c->forked_inferior_pid));
8152 uiout->spaces (1);
ce78b96d 8153 }
8ac3646f 8154
112e8700
SM
8155 if (uiout->is_mi_like_p ())
8156 uiout->field_string ("catch-type", "fork");
ce78b96d
JB
8157}
8158
8159/* Implement the "print_mention" breakpoint_ops method for fork
8160 catchpoints. */
8161
8162static void
8163print_mention_catch_fork (struct breakpoint *b)
8164{
8165 printf_filtered (_("Catchpoint %d (fork)"), b->number);
8166}
8167
6149aea9
PA
8168/* Implement the "print_recreate" breakpoint_ops method for fork
8169 catchpoints. */
8170
8171static void
8172print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
8173{
8174 fprintf_unfiltered (fp, "catch fork");
d9b3f62e 8175 print_recreate_thread (b, fp);
6149aea9
PA
8176}
8177
ce78b96d
JB
8178/* The breakpoint_ops structure to be used in fork catchpoints. */
8179
2060206e 8180static struct breakpoint_ops catch_fork_breakpoint_ops;
ce78b96d 8181
4a64f543
MS
8182/* Implement the "insert" breakpoint_ops method for vfork
8183 catchpoints. */
ce78b96d 8184
77b06cd7
TJB
8185static int
8186insert_catch_vfork (struct bp_location *bl)
ce78b96d 8187{
dfd4cc63 8188 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid));
ce78b96d
JB
8189}
8190
4a64f543
MS
8191/* Implement the "remove" breakpoint_ops method for vfork
8192 catchpoints. */
ce78b96d
JB
8193
8194static int
73971819 8195remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason)
ce78b96d 8196{
dfd4cc63 8197 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid));
ce78b96d
JB
8198}
8199
8200/* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8201 catchpoints. */
8202
8203static int
f1310107 8204breakpoint_hit_catch_vfork (const struct bp_location *bl,
09ac7c10
TT
8205 struct address_space *aspace, CORE_ADDR bp_addr,
8206 const struct target_waitstatus *ws)
ce78b96d 8207{
e29a4733
PA
8208 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
8209
f90263c1
TT
8210 if (ws->kind != TARGET_WAITKIND_VFORKED)
8211 return 0;
8212
8213 c->forked_inferior_pid = ws->value.related_pid;
8214 return 1;
ce78b96d
JB
8215}
8216
4a64f543
MS
8217/* Implement the "print_it" breakpoint_ops method for vfork
8218 catchpoints. */
ce78b96d
JB
8219
8220static enum print_stop_action
348d480f 8221print_it_catch_vfork (bpstat bs)
ce78b96d 8222{
36dfb11c 8223 struct ui_out *uiout = current_uiout;
348d480f 8224 struct breakpoint *b = bs->breakpoint_at;
e29a4733
PA
8225 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
8226
ce78b96d 8227 annotate_catchpoint (b->number);
f303dbd6 8228 maybe_print_thread_hit_breakpoint (uiout);
36dfb11c 8229 if (b->disposition == disp_del)
112e8700 8230 uiout->text ("Temporary catchpoint ");
36dfb11c 8231 else
112e8700
SM
8232 uiout->text ("Catchpoint ");
8233 if (uiout->is_mi_like_p ())
36dfb11c 8234 {
112e8700
SM
8235 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
8236 uiout->field_string ("disp", bpdisp_text (b->disposition));
36dfb11c 8237 }
112e8700
SM
8238 uiout->field_int ("bkptno", b->number);
8239 uiout->text (" (vforked process ");
8240 uiout->field_int ("newpid", ptid_get_pid (c->forked_inferior_pid));
8241 uiout->text ("), ");
ce78b96d
JB
8242 return PRINT_SRC_AND_LOC;
8243}
8244
4a64f543
MS
8245/* Implement the "print_one" breakpoint_ops method for vfork
8246 catchpoints. */
ce78b96d
JB
8247
8248static void
a6d9a66e 8249print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
ce78b96d 8250{
e29a4733 8251 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
79a45b7d 8252 struct value_print_options opts;
79a45e25 8253 struct ui_out *uiout = current_uiout;
79a45b7d
TT
8254
8255 get_user_print_options (&opts);
4a64f543
MS
8256 /* Field 4, the address, is omitted (which makes the columns not
8257 line up too nicely with the headers, but the effect is relatively
8258 readable). */
79a45b7d 8259 if (opts.addressprint)
112e8700 8260 uiout->field_skip ("addr");
ce78b96d 8261 annotate_field (5);
112e8700 8262 uiout->text ("vfork");
e29a4733 8263 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
ce78b96d 8264 {
112e8700
SM
8265 uiout->text (", process ");
8266 uiout->field_int ("what", ptid_get_pid (c->forked_inferior_pid));
8267 uiout->spaces (1);
ce78b96d 8268 }
8ac3646f 8269
112e8700
SM
8270 if (uiout->is_mi_like_p ())
8271 uiout->field_string ("catch-type", "vfork");
ce78b96d
JB
8272}
8273
8274/* Implement the "print_mention" breakpoint_ops method for vfork
8275 catchpoints. */
8276
8277static void
8278print_mention_catch_vfork (struct breakpoint *b)
8279{
8280 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
8281}
8282
6149aea9
PA
8283/* Implement the "print_recreate" breakpoint_ops method for vfork
8284 catchpoints. */
8285
8286static void
8287print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
8288{
8289 fprintf_unfiltered (fp, "catch vfork");
d9b3f62e 8290 print_recreate_thread (b, fp);
6149aea9
PA
8291}
8292
ce78b96d
JB
8293/* The breakpoint_ops structure to be used in vfork catchpoints. */
8294
2060206e 8295static struct breakpoint_ops catch_vfork_breakpoint_ops;
ce78b96d 8296
edcc5120
TT
8297/* An instance of this type is used to represent an solib catchpoint.
8298 It includes a "struct breakpoint" as a kind of base class; users
8299 downcast to "struct breakpoint *" when needed. A breakpoint is
8300 really of this type iff its ops pointer points to
8301 CATCH_SOLIB_BREAKPOINT_OPS. */
8302
8303struct solib_catchpoint
8304{
8305 /* The base class. */
8306 struct breakpoint base;
8307
8308 /* True for "catch load", false for "catch unload". */
8309 unsigned char is_load;
8310
8311 /* Regular expression to match, if any. COMPILED is only valid when
8312 REGEX is non-NULL. */
8313 char *regex;
8314 regex_t compiled;
8315};
8316
8317static void
8318dtor_catch_solib (struct breakpoint *b)
8319{
8320 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8321
8322 if (self->regex)
8323 regfree (&self->compiled);
8324 xfree (self->regex);
8325
8326 base_breakpoint_ops.dtor (b);
8327}
8328
8329static int
8330insert_catch_solib (struct bp_location *ignore)
8331{
8332 return 0;
8333}
8334
8335static int
73971819 8336remove_catch_solib (struct bp_location *ignore, enum remove_bp_reason reason)
edcc5120
TT
8337{
8338 return 0;
8339}
8340
8341static int
8342breakpoint_hit_catch_solib (const struct bp_location *bl,
8343 struct address_space *aspace,
8344 CORE_ADDR bp_addr,
8345 const struct target_waitstatus *ws)
8346{
8347 struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
8348 struct breakpoint *other;
8349
8350 if (ws->kind == TARGET_WAITKIND_LOADED)
8351 return 1;
8352
8353 ALL_BREAKPOINTS (other)
8354 {
8355 struct bp_location *other_bl;
8356
8357 if (other == bl->owner)
8358 continue;
8359
8360 if (other->type != bp_shlib_event)
8361 continue;
8362
8363 if (self->base.pspace != NULL && other->pspace != self->base.pspace)
8364 continue;
8365
8366 for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
8367 {
8368 if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
8369 return 1;
8370 }
8371 }
8372
8373 return 0;
8374}
8375
8376static void
8377check_status_catch_solib (struct bpstats *bs)
8378{
8379 struct solib_catchpoint *self
8380 = (struct solib_catchpoint *) bs->breakpoint_at;
8381 int ix;
8382
8383 if (self->is_load)
8384 {
8385 struct so_list *iter;
8386
8387 for (ix = 0;
8388 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
8389 ix, iter);
8390 ++ix)
8391 {
8392 if (!self->regex
8393 || regexec (&self->compiled, iter->so_name, 0, NULL, 0) == 0)
8394 return;
8395 }
8396 }
8397 else
8398 {
8399 char *iter;
8400
8401 for (ix = 0;
8402 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
8403 ix, iter);
8404 ++ix)
8405 {
8406 if (!self->regex
8407 || regexec (&self->compiled, iter, 0, NULL, 0) == 0)
8408 return;
8409 }
8410 }
8411
8412 bs->stop = 0;
8413 bs->print_it = print_it_noop;
8414}
8415
8416static enum print_stop_action
8417print_it_catch_solib (bpstat bs)
8418{
8419 struct breakpoint *b = bs->breakpoint_at;
8420 struct ui_out *uiout = current_uiout;
8421
8422 annotate_catchpoint (b->number);
f303dbd6 8423 maybe_print_thread_hit_breakpoint (uiout);
edcc5120 8424 if (b->disposition == disp_del)
112e8700 8425 uiout->text ("Temporary catchpoint ");
edcc5120 8426 else
112e8700
SM
8427 uiout->text ("Catchpoint ");
8428 uiout->field_int ("bkptno", b->number);
8429 uiout->text ("\n");
8430 if (uiout->is_mi_like_p ())
8431 uiout->field_string ("disp", bpdisp_text (b->disposition));
edcc5120
TT
8432 print_solib_event (1);
8433 return PRINT_SRC_AND_LOC;
8434}
8435
8436static void
8437print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
8438{
8439 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8440 struct value_print_options opts;
8441 struct ui_out *uiout = current_uiout;
8442 char *msg;
8443
8444 get_user_print_options (&opts);
8445 /* Field 4, the address, is omitted (which makes the columns not
8446 line up too nicely with the headers, but the effect is relatively
8447 readable). */
8448 if (opts.addressprint)
8449 {
8450 annotate_field (4);
112e8700 8451 uiout->field_skip ("addr");
edcc5120
TT
8452 }
8453
8454 annotate_field (5);
8455 if (self->is_load)
8456 {
8457 if (self->regex)
8458 msg = xstrprintf (_("load of library matching %s"), self->regex);
8459 else
8460 msg = xstrdup (_("load of library"));
8461 }
8462 else
8463 {
8464 if (self->regex)
8465 msg = xstrprintf (_("unload of library matching %s"), self->regex);
8466 else
8467 msg = xstrdup (_("unload of library"));
8468 }
112e8700 8469 uiout->field_string ("what", msg);
edcc5120 8470 xfree (msg);
8ac3646f 8471
112e8700
SM
8472 if (uiout->is_mi_like_p ())
8473 uiout->field_string ("catch-type", self->is_load ? "load" : "unload");
edcc5120
TT
8474}
8475
8476static void
8477print_mention_catch_solib (struct breakpoint *b)
8478{
8479 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8480
8481 printf_filtered (_("Catchpoint %d (%s)"), b->number,
8482 self->is_load ? "load" : "unload");
8483}
8484
8485static void
8486print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8487{
8488 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8489
8490 fprintf_unfiltered (fp, "%s %s",
8491 b->disposition == disp_del ? "tcatch" : "catch",
8492 self->is_load ? "load" : "unload");
8493 if (self->regex)
8494 fprintf_unfiltered (fp, " %s", self->regex);
8495 fprintf_unfiltered (fp, "\n");
8496}
8497
8498static struct breakpoint_ops catch_solib_breakpoint_ops;
8499
91985142
MG
8500/* Shared helper function (MI and CLI) for creating and installing
8501 a shared object event catchpoint. If IS_LOAD is non-zero then
8502 the events to be caught are load events, otherwise they are
8503 unload events. If IS_TEMP is non-zero the catchpoint is a
8504 temporary one. If ENABLED is non-zero the catchpoint is
8505 created in an enabled state. */
edcc5120 8506
91985142 8507void
a121b7c1 8508add_solib_catchpoint (const char *arg, int is_load, int is_temp, int enabled)
edcc5120
TT
8509{
8510 struct solib_catchpoint *c;
8511 struct gdbarch *gdbarch = get_current_arch ();
edcc5120
TT
8512 struct cleanup *cleanup;
8513
edcc5120
TT
8514 if (!arg)
8515 arg = "";
a121b7c1 8516 arg = skip_spaces_const (arg);
edcc5120 8517
4d01a485 8518 c = new solib_catchpoint ();
edcc5120
TT
8519 cleanup = make_cleanup (xfree, c);
8520
8521 if (*arg != '\0')
8522 {
8523 int errcode;
8524
8525 errcode = regcomp (&c->compiled, arg, REG_NOSUB);
8526 if (errcode != 0)
8527 {
8528 char *err = get_regcomp_error (errcode, &c->compiled);
8529
8530 make_cleanup (xfree, err);
8531 error (_("Invalid regexp (%s): %s"), err, arg);
8532 }
8533 c->regex = xstrdup (arg);
8534 }
8535
8536 c->is_load = is_load;
91985142 8537 init_catchpoint (&c->base, gdbarch, is_temp, NULL,
edcc5120
TT
8538 &catch_solib_breakpoint_ops);
8539
91985142
MG
8540 c->base.enable_state = enabled ? bp_enabled : bp_disabled;
8541
edcc5120
TT
8542 discard_cleanups (cleanup);
8543 install_breakpoint (0, &c->base, 1);
8544}
8545
91985142
MG
8546/* A helper function that does all the work for "catch load" and
8547 "catch unload". */
8548
8549static void
8550catch_load_or_unload (char *arg, int from_tty, int is_load,
8551 struct cmd_list_element *command)
8552{
8553 int tempflag;
8554 const int enabled = 1;
8555
8556 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8557
8558 add_solib_catchpoint (arg, is_load, tempflag, enabled);
8559}
8560
edcc5120
TT
8561static void
8562catch_load_command_1 (char *arg, int from_tty,
8563 struct cmd_list_element *command)
8564{
8565 catch_load_or_unload (arg, from_tty, 1, command);
8566}
8567
8568static void
8569catch_unload_command_1 (char *arg, int from_tty,
8570 struct cmd_list_element *command)
8571{
8572 catch_load_or_unload (arg, from_tty, 0, command);
8573}
8574
346774a9
PA
8575/* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8576 is non-zero, then make the breakpoint temporary. If COND_STRING is
8577 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8578 the breakpoint_ops structure associated to the catchpoint. */
ce78b96d 8579
ab04a2af 8580void
346774a9
PA
8581init_catchpoint (struct breakpoint *b,
8582 struct gdbarch *gdbarch, int tempflag,
63160a43 8583 const char *cond_string,
c0a91b2b 8584 const struct breakpoint_ops *ops)
c906108c 8585{
c5aa993b 8586 struct symtab_and_line sal;
346774a9 8587
fe39c653 8588 init_sal (&sal);
6c95b8df 8589 sal.pspace = current_program_space;
c5aa993b 8590
28010a5d 8591 init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
ce78b96d 8592
1b36a34b 8593 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
b5de0fa7 8594 b->disposition = tempflag ? disp_del : disp_donttouch;
346774a9
PA
8595}
8596
28010a5d 8597void
3ea46bff 8598install_breakpoint (int internal, struct breakpoint *b, int update_gll)
c56053d2
PA
8599{
8600 add_to_breakpoint_chain (b);
3a5c3e22 8601 set_breakpoint_number (internal, b);
558a9d82
YQ
8602 if (is_tracepoint (b))
8603 set_tracepoint_count (breakpoint_count);
3a5c3e22
PA
8604 if (!internal)
8605 mention (b);
c56053d2 8606 observer_notify_breakpoint_created (b);
3ea46bff
YQ
8607
8608 if (update_gll)
44702360 8609 update_global_location_list (UGLL_MAY_INSERT);
c56053d2
PA
8610}
8611
9b70b993 8612static void
a6d9a66e 8613create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
63160a43 8614 int tempflag, const char *cond_string,
c0a91b2b 8615 const struct breakpoint_ops *ops)
c906108c 8616{
4d01a485 8617 struct fork_catchpoint *c = new fork_catchpoint ();
ce78b96d 8618
e29a4733
PA
8619 init_catchpoint (&c->base, gdbarch, tempflag, cond_string, ops);
8620
8621 c->forked_inferior_pid = null_ptid;
8622
3ea46bff 8623 install_breakpoint (0, &c->base, 1);
c906108c
SS
8624}
8625
fe798b75
JB
8626/* Exec catchpoints. */
8627
b4d90040
PA
8628/* An instance of this type is used to represent an exec catchpoint.
8629 It includes a "struct breakpoint" as a kind of base class; users
8630 downcast to "struct breakpoint *" when needed. A breakpoint is
8631 really of this type iff its ops pointer points to
8632 CATCH_EXEC_BREAKPOINT_OPS. */
8633
8634struct exec_catchpoint
8635{
8636 /* The base class. */
8637 struct breakpoint base;
8638
8639 /* Filename of a program whose exec triggered this catchpoint.
8640 This field is only valid immediately after this catchpoint has
8641 triggered. */
8642 char *exec_pathname;
8643};
8644
8645/* Implement the "dtor" breakpoint_ops method for exec
8646 catchpoints. */
8647
8648static void
8649dtor_catch_exec (struct breakpoint *b)
8650{
8651 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8652
8653 xfree (c->exec_pathname);
348d480f 8654
2060206e 8655 base_breakpoint_ops.dtor (b);
b4d90040
PA
8656}
8657
77b06cd7
TJB
8658static int
8659insert_catch_exec (struct bp_location *bl)
c906108c 8660{
dfd4cc63 8661 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid));
fe798b75 8662}
c906108c 8663
fe798b75 8664static int
73971819 8665remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason)
fe798b75 8666{
dfd4cc63 8667 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid));
fe798b75 8668}
c906108c 8669
fe798b75 8670static int
f1310107 8671breakpoint_hit_catch_exec (const struct bp_location *bl,
09ac7c10
TT
8672 struct address_space *aspace, CORE_ADDR bp_addr,
8673 const struct target_waitstatus *ws)
fe798b75 8674{
b4d90040
PA
8675 struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8676
f90263c1
TT
8677 if (ws->kind != TARGET_WAITKIND_EXECD)
8678 return 0;
8679
8680 c->exec_pathname = xstrdup (ws->value.execd_pathname);
8681 return 1;
fe798b75 8682}
c906108c 8683
fe798b75 8684static enum print_stop_action
348d480f 8685print_it_catch_exec (bpstat bs)
fe798b75 8686{
36dfb11c 8687 struct ui_out *uiout = current_uiout;
348d480f 8688 struct breakpoint *b = bs->breakpoint_at;
b4d90040
PA
8689 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8690
fe798b75 8691 annotate_catchpoint (b->number);
f303dbd6 8692 maybe_print_thread_hit_breakpoint (uiout);
36dfb11c 8693 if (b->disposition == disp_del)
112e8700 8694 uiout->text ("Temporary catchpoint ");
36dfb11c 8695 else
112e8700
SM
8696 uiout->text ("Catchpoint ");
8697 if (uiout->is_mi_like_p ())
36dfb11c 8698 {
112e8700
SM
8699 uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
8700 uiout->field_string ("disp", bpdisp_text (b->disposition));
36dfb11c 8701 }
112e8700
SM
8702 uiout->field_int ("bkptno", b->number);
8703 uiout->text (" (exec'd ");
8704 uiout->field_string ("new-exec", c->exec_pathname);
8705 uiout->text ("), ");
36dfb11c 8706
fe798b75 8707 return PRINT_SRC_AND_LOC;
c906108c
SS
8708}
8709
fe798b75 8710static void
a6d9a66e 8711print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
fe798b75 8712{
b4d90040 8713 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
fe798b75 8714 struct value_print_options opts;
79a45e25 8715 struct ui_out *uiout = current_uiout;
fe798b75
JB
8716
8717 get_user_print_options (&opts);
8718
8719 /* Field 4, the address, is omitted (which makes the columns
8720 not line up too nicely with the headers, but the effect
8721 is relatively readable). */
8722 if (opts.addressprint)
112e8700 8723 uiout->field_skip ("addr");
fe798b75 8724 annotate_field (5);
112e8700 8725 uiout->text ("exec");
b4d90040 8726 if (c->exec_pathname != NULL)
fe798b75 8727 {
112e8700
SM
8728 uiout->text (", program \"");
8729 uiout->field_string ("what", c->exec_pathname);
8730 uiout->text ("\" ");
fe798b75 8731 }
8ac3646f 8732
112e8700
SM
8733 if (uiout->is_mi_like_p ())
8734 uiout->field_string ("catch-type", "exec");
fe798b75
JB
8735}
8736
8737static void
8738print_mention_catch_exec (struct breakpoint *b)
8739{
8740 printf_filtered (_("Catchpoint %d (exec)"), b->number);
8741}
8742
6149aea9
PA
8743/* Implement the "print_recreate" breakpoint_ops method for exec
8744 catchpoints. */
8745
8746static void
8747print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8748{
8749 fprintf_unfiltered (fp, "catch exec");
d9b3f62e 8750 print_recreate_thread (b, fp);
6149aea9
PA
8751}
8752
2060206e 8753static struct breakpoint_ops catch_exec_breakpoint_ops;
fe798b75 8754
c906108c 8755static int
fba45db2 8756hw_breakpoint_used_count (void)
c906108c 8757{
c906108c 8758 int i = 0;
f1310107
TJB
8759 struct breakpoint *b;
8760 struct bp_location *bl;
c906108c
SS
8761
8762 ALL_BREAKPOINTS (b)
c5aa993b 8763 {
d6b74ac4 8764 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
f1310107
TJB
8765 for (bl = b->loc; bl; bl = bl->next)
8766 {
8767 /* Special types of hardware breakpoints may use more than
8768 one register. */
348d480f 8769 i += b->ops->resources_needed (bl);
f1310107 8770 }
c5aa993b 8771 }
c906108c
SS
8772
8773 return i;
8774}
8775
a1398e0c
PA
8776/* Returns the resources B would use if it were a hardware
8777 watchpoint. */
8778
c906108c 8779static int
a1398e0c 8780hw_watchpoint_use_count (struct breakpoint *b)
c906108c 8781{
c906108c 8782 int i = 0;
e09342b5 8783 struct bp_location *bl;
c906108c 8784
a1398e0c
PA
8785 if (!breakpoint_enabled (b))
8786 return 0;
8787
8788 for (bl = b->loc; bl; bl = bl->next)
8789 {
8790 /* Special types of hardware watchpoints may use more than
8791 one register. */
8792 i += b->ops->resources_needed (bl);
8793 }
8794
8795 return i;
8796}
8797
8798/* Returns the sum the used resources of all hardware watchpoints of
8799 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8800 the sum of the used resources of all hardware watchpoints of other
8801 types _not_ TYPE. */
8802
8803static int
8804hw_watchpoint_used_count_others (struct breakpoint *except,
8805 enum bptype type, int *other_type_used)
8806{
8807 int i = 0;
8808 struct breakpoint *b;
8809
c906108c
SS
8810 *other_type_used = 0;
8811 ALL_BREAKPOINTS (b)
e09342b5 8812 {
a1398e0c
PA
8813 if (b == except)
8814 continue;
e09342b5
TJB
8815 if (!breakpoint_enabled (b))
8816 continue;
8817
a1398e0c
PA
8818 if (b->type == type)
8819 i += hw_watchpoint_use_count (b);
8820 else if (is_hardware_watchpoint (b))
8821 *other_type_used = 1;
e09342b5
TJB
8822 }
8823
c906108c
SS
8824 return i;
8825}
8826
c906108c 8827void
fba45db2 8828disable_watchpoints_before_interactive_call_start (void)
c906108c 8829{
c5aa993b 8830 struct breakpoint *b;
c906108c
SS
8831
8832 ALL_BREAKPOINTS (b)
c5aa993b 8833 {
cc60f2e3 8834 if (is_watchpoint (b) && breakpoint_enabled (b))
c5aa993b 8835 {
b5de0fa7 8836 b->enable_state = bp_call_disabled;
44702360 8837 update_global_location_list (UGLL_DONT_INSERT);
c5aa993b
JM
8838 }
8839 }
c906108c
SS
8840}
8841
8842void
fba45db2 8843enable_watchpoints_after_interactive_call_stop (void)
c906108c 8844{
c5aa993b 8845 struct breakpoint *b;
c906108c
SS
8846
8847 ALL_BREAKPOINTS (b)
c5aa993b 8848 {
cc60f2e3 8849 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
c5aa993b 8850 {
b5de0fa7 8851 b->enable_state = bp_enabled;
44702360 8852 update_global_location_list (UGLL_MAY_INSERT);
c5aa993b
JM
8853 }
8854 }
c906108c
SS
8855}
8856
8bea4e01
UW
8857void
8858disable_breakpoints_before_startup (void)
8859{
6c95b8df 8860 current_program_space->executing_startup = 1;
44702360 8861 update_global_location_list (UGLL_DONT_INSERT);
8bea4e01
UW
8862}
8863
8864void
8865enable_breakpoints_after_startup (void)
8866{
6c95b8df 8867 current_program_space->executing_startup = 0;
f8eba3c6 8868 breakpoint_re_set ();
8bea4e01
UW
8869}
8870
7c16b83e
PA
8871/* Create a new single-step breakpoint for thread THREAD, with no
8872 locations. */
c906108c 8873
7c16b83e
PA
8874static struct breakpoint *
8875new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
8876{
4d01a485 8877 struct breakpoint *b = new breakpoint ();
7c16b83e
PA
8878
8879 init_raw_breakpoint_without_location (b, gdbarch, bp_single_step,
8880 &momentary_breakpoint_ops);
8881
8882 b->disposition = disp_donttouch;
8883 b->frame_id = null_frame_id;
8884
8885 b->thread = thread;
8886 gdb_assert (b->thread != 0);
8887
8888 add_to_breakpoint_chain (b);
8889
8890 return b;
8891}
8892
8893/* Set a momentary breakpoint of type TYPE at address specified by
8894 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8895 frame. */
c906108c
SS
8896
8897struct breakpoint *
a6d9a66e
UW
8898set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8899 struct frame_id frame_id, enum bptype type)
c906108c 8900{
52f0bd74 8901 struct breakpoint *b;
edb3359d 8902
193facb3
JK
8903 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8904 tail-called one. */
8905 gdb_assert (!frame_id_artificial_p (frame_id));
edb3359d 8906
06edf0c0 8907 b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
b5de0fa7
EZ
8908 b->enable_state = bp_enabled;
8909 b->disposition = disp_donttouch;
818dd999 8910 b->frame_id = frame_id;
c906108c 8911
4a64f543
MS
8912 /* If we're debugging a multi-threaded program, then we want
8913 momentary breakpoints to be active in only a single thread of
8914 control. */
39f77062 8915 if (in_thread_list (inferior_ptid))
5d5658a1 8916 b->thread = ptid_to_global_thread_id (inferior_ptid);
c906108c 8917
44702360 8918 update_global_location_list_nothrow (UGLL_MAY_INSERT);
74960c60 8919
c906108c
SS
8920 return b;
8921}
611c83ae 8922
06edf0c0 8923/* Make a momentary breakpoint based on the master breakpoint ORIG.
a1aa2221
LM
8924 The new breakpoint will have type TYPE, use OPS as its
8925 breakpoint_ops, and will set enabled to LOC_ENABLED. */
e58b0e63 8926
06edf0c0
PA
8927static struct breakpoint *
8928momentary_breakpoint_from_master (struct breakpoint *orig,
8929 enum bptype type,
a1aa2221
LM
8930 const struct breakpoint_ops *ops,
8931 int loc_enabled)
e58b0e63
PA
8932{
8933 struct breakpoint *copy;
8934
06edf0c0 8935 copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
e58b0e63 8936 copy->loc = allocate_bp_location (copy);
0e30163f 8937 set_breakpoint_location_function (copy->loc, 1);
e58b0e63 8938
a6d9a66e 8939 copy->loc->gdbarch = orig->loc->gdbarch;
e58b0e63
PA
8940 copy->loc->requested_address = orig->loc->requested_address;
8941 copy->loc->address = orig->loc->address;
8942 copy->loc->section = orig->loc->section;
6c95b8df 8943 copy->loc->pspace = orig->loc->pspace;
55aa24fb 8944 copy->loc->probe = orig->loc->probe;
f8eba3c6 8945 copy->loc->line_number = orig->loc->line_number;
2f202fde 8946 copy->loc->symtab = orig->loc->symtab;
a1aa2221 8947 copy->loc->enabled = loc_enabled;
e58b0e63
PA
8948 copy->frame_id = orig->frame_id;
8949 copy->thread = orig->thread;
6c95b8df 8950 copy->pspace = orig->pspace;
e58b0e63
PA
8951
8952 copy->enable_state = bp_enabled;
8953 copy->disposition = disp_donttouch;
8954 copy->number = internal_breakpoint_number--;
8955
44702360 8956 update_global_location_list_nothrow (UGLL_DONT_INSERT);
e58b0e63
PA
8957 return copy;
8958}
8959
06edf0c0
PA
8960/* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8961 ORIG is NULL. */
8962
8963struct breakpoint *
8964clone_momentary_breakpoint (struct breakpoint *orig)
8965{
8966 /* If there's nothing to clone, then return nothing. */
8967 if (orig == NULL)
8968 return NULL;
8969
a1aa2221 8970 return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
06edf0c0
PA
8971}
8972
611c83ae 8973struct breakpoint *
a6d9a66e
UW
8974set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8975 enum bptype type)
611c83ae
PA
8976{
8977 struct symtab_and_line sal;
8978
8979 sal = find_pc_line (pc, 0);
8980 sal.pc = pc;
8981 sal.section = find_pc_overlay (pc);
8982 sal.explicit_pc = 1;
8983
a6d9a66e 8984 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
611c83ae 8985}
c906108c 8986\f
c5aa993b 8987
c906108c
SS
8988/* Tell the user we have just set a breakpoint B. */
8989
8990static void
fba45db2 8991mention (struct breakpoint *b)
c906108c 8992{
348d480f 8993 b->ops->print_mention (b);
112e8700 8994 if (current_uiout->is_mi_like_p ())
fb40c209 8995 return;
c906108c
SS
8996 printf_filtered ("\n");
8997}
c906108c 8998\f
c5aa993b 8999
1a853c52
PA
9000static int bp_loc_is_permanent (struct bp_location *loc);
9001
0d381245 9002static struct bp_location *
39d61571 9003add_location_to_breakpoint (struct breakpoint *b,
0d381245
VP
9004 const struct symtab_and_line *sal)
9005{
9006 struct bp_location *loc, **tmp;
3742cc8b
YQ
9007 CORE_ADDR adjusted_address;
9008 struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
9009
9010 if (loc_gdbarch == NULL)
9011 loc_gdbarch = b->gdbarch;
9012
9013 /* Adjust the breakpoint's address prior to allocating a location.
9014 Once we call allocate_bp_location(), that mostly uninitialized
9015 location will be placed on the location chain. Adjustment of the
9016 breakpoint may cause target_read_memory() to be called and we do
9017 not want its scan of the location chain to find a breakpoint and
9018 location that's only been partially initialized. */
9019 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
9020 sal->pc, b->type);
0d381245 9021
d30113d4 9022 /* Sort the locations by their ADDRESS. */
39d61571 9023 loc = allocate_bp_location (b);
d30113d4
JK
9024 for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
9025 tmp = &((*tmp)->next))
0d381245 9026 ;
d30113d4 9027 loc->next = *tmp;
0d381245 9028 *tmp = loc;
3742cc8b 9029
0d381245 9030 loc->requested_address = sal->pc;
3742cc8b 9031 loc->address = adjusted_address;
6c95b8df 9032 loc->pspace = sal->pspace;
729662a5
TT
9033 loc->probe.probe = sal->probe;
9034 loc->probe.objfile = sal->objfile;
6c95b8df 9035 gdb_assert (loc->pspace != NULL);
0d381245 9036 loc->section = sal->section;
3742cc8b 9037 loc->gdbarch = loc_gdbarch;
f8eba3c6 9038 loc->line_number = sal->line;
2f202fde 9039 loc->symtab = sal->symtab;
f8eba3c6 9040
0e30163f
JK
9041 set_breakpoint_location_function (loc,
9042 sal->explicit_pc || sal->explicit_line);
1a853c52 9043
6ae88661
LM
9044 /* While by definition, permanent breakpoints are already present in the
9045 code, we don't mark the location as inserted. Normally one would expect
9046 that GDB could rely on that breakpoint instruction to stop the program,
9047 thus removing the need to insert its own breakpoint, except that executing
9048 the breakpoint instruction can kill the target instead of reporting a
9049 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
9050 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
9051 with "Trap 0x02 while interrupts disabled, Error state". Letting the
9052 breakpoint be inserted normally results in QEMU knowing about the GDB
9053 breakpoint, and thus trap before the breakpoint instruction is executed.
9054 (If GDB later needs to continue execution past the permanent breakpoint,
9055 it manually increments the PC, thus avoiding executing the breakpoint
9056 instruction.) */
1a853c52 9057 if (bp_loc_is_permanent (loc))
6ae88661 9058 loc->permanent = 1;
1a853c52 9059
0d381245
VP
9060 return loc;
9061}
514f746b
AR
9062\f
9063
1cf4d951 9064/* See breakpoint.h. */
514f746b 9065
1cf4d951
PA
9066int
9067program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
514f746b
AR
9068{
9069 int len;
9070 CORE_ADDR addr;
1afeeb75 9071 const gdb_byte *bpoint;
514f746b 9072 gdb_byte *target_mem;
939c61fa
JK
9073 struct cleanup *cleanup;
9074 int retval = 0;
514f746b 9075
1cf4d951
PA
9076 addr = address;
9077 bpoint = gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
9078
9079 /* Software breakpoints unsupported? */
9080 if (bpoint == NULL)
9081 return 0;
9082
224c3ddb 9083 target_mem = (gdb_byte *) alloca (len);
1cf4d951
PA
9084
9085 /* Enable the automatic memory restoration from breakpoints while
9086 we read the memory. Otherwise we could say about our temporary
9087 breakpoints they are permanent. */
9088 cleanup = make_show_memory_breakpoints_cleanup (0);
9089
9090 if (target_read_memory (address, target_mem, len) == 0
9091 && memcmp (target_mem, bpoint, len) == 0)
9092 retval = 1;
9093
9094 do_cleanups (cleanup);
9095
9096 return retval;
9097}
9098
9099/* Return 1 if LOC is pointing to a permanent breakpoint,
9100 return 0 otherwise. */
9101
9102static int
9103bp_loc_is_permanent (struct bp_location *loc)
9104{
9105 struct cleanup *cleanup;
9106 int retval;
9107
514f746b
AR
9108 gdb_assert (loc != NULL);
9109
244558af
LM
9110 /* If we have a catchpoint or a watchpoint, just return 0. We should not
9111 attempt to read from the addresses the locations of these breakpoint types
9112 point to. program_breakpoint_here_p, below, will attempt to read
9113 memory. */
9114 if (!breakpoint_address_is_meaningful (loc->owner))
9115 return 0;
9116
6c95b8df 9117 cleanup = save_current_space_and_thread ();
6c95b8df 9118 switch_to_program_space_and_thread (loc->pspace);
939c61fa 9119
1cf4d951 9120 retval = program_breakpoint_here_p (loc->gdbarch, loc->address);
514f746b 9121
939c61fa
JK
9122 do_cleanups (cleanup);
9123
9124 return retval;
514f746b
AR
9125}
9126
e7e0cddf
SS
9127/* Build a command list for the dprintf corresponding to the current
9128 settings of the dprintf style options. */
9129
9130static void
9131update_dprintf_command_list (struct breakpoint *b)
9132{
9133 char *dprintf_args = b->extra_string;
9134 char *printf_line = NULL;
9135
9136 if (!dprintf_args)
9137 return;
9138
9139 dprintf_args = skip_spaces (dprintf_args);
9140
9141 /* Allow a comma, as it may have terminated a location, but don't
9142 insist on it. */
9143 if (*dprintf_args == ',')
9144 ++dprintf_args;
9145 dprintf_args = skip_spaces (dprintf_args);
9146
9147 if (*dprintf_args != '"')
9148 error (_("Bad format string, missing '\"'."));
9149
d3ce09f5 9150 if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
e7e0cddf 9151 printf_line = xstrprintf ("printf %s", dprintf_args);
d3ce09f5 9152 else if (strcmp (dprintf_style, dprintf_style_call) == 0)
e7e0cddf
SS
9153 {
9154 if (!dprintf_function)
9155 error (_("No function supplied for dprintf call"));
9156
9157 if (dprintf_channel && strlen (dprintf_channel) > 0)
9158 printf_line = xstrprintf ("call (void) %s (%s,%s)",
9159 dprintf_function,
9160 dprintf_channel,
9161 dprintf_args);
9162 else
9163 printf_line = xstrprintf ("call (void) %s (%s)",
9164 dprintf_function,
9165 dprintf_args);
9166 }
d3ce09f5
SS
9167 else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
9168 {
9169 if (target_can_run_breakpoint_commands ())
9170 printf_line = xstrprintf ("agent-printf %s", dprintf_args);
9171 else
9172 {
9173 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9174 printf_line = xstrprintf ("printf %s", dprintf_args);
9175 }
9176 }
e7e0cddf
SS
9177 else
9178 internal_error (__FILE__, __LINE__,
9179 _("Invalid dprintf style."));
9180
f28045c2 9181 gdb_assert (printf_line != NULL);
9d6e6e84 9182 /* Manufacture a printf sequence. */
f28045c2 9183 {
8d749320 9184 struct command_line *printf_cmd_line = XNEW (struct command_line);
e7e0cddf 9185
f28045c2
YQ
9186 printf_cmd_line->control_type = simple_control;
9187 printf_cmd_line->body_count = 0;
9188 printf_cmd_line->body_list = NULL;
9d6e6e84 9189 printf_cmd_line->next = NULL;
f28045c2 9190 printf_cmd_line->line = printf_line;
e7e0cddf 9191
93921405 9192 breakpoint_set_commands (b, command_line_up (printf_cmd_line));
f28045c2 9193 }
e7e0cddf
SS
9194}
9195
9196/* Update all dprintf commands, making their command lists reflect
9197 current style settings. */
9198
9199static void
9200update_dprintf_commands (char *args, int from_tty,
9201 struct cmd_list_element *c)
9202{
9203 struct breakpoint *b;
9204
9205 ALL_BREAKPOINTS (b)
9206 {
9207 if (b->type == bp_dprintf)
9208 update_dprintf_command_list (b);
9209 }
9210}
c3f6f71d 9211
f00aae0f
KS
9212/* Create a breakpoint with SAL as location. Use LOCATION
9213 as a description of the location, and COND_STRING
b35a8b2f
DE
9214 as condition expression. If LOCATION is NULL then create an
9215 "address location" from the address in the SAL. */
018d34a4
VP
9216
9217static void
d9b3f62e 9218init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
f00aae0f 9219 struct symtabs_and_lines sals,
ffc2605c 9220 event_location_up &&location,
f8eba3c6 9221 char *filter, char *cond_string,
e7e0cddf 9222 char *extra_string,
d9b3f62e
PA
9223 enum bptype type, enum bpdisp disposition,
9224 int thread, int task, int ignore_count,
c0a91b2b 9225 const struct breakpoint_ops *ops, int from_tty,
44f238bb
PA
9226 int enabled, int internal, unsigned flags,
9227 int display_canonical)
018d34a4 9228{
0d381245 9229 int i;
018d34a4
VP
9230
9231 if (type == bp_hardware_breakpoint)
9232 {
fbbd034e
AS
9233 int target_resources_ok;
9234
9235 i = hw_breakpoint_used_count ();
9236 target_resources_ok =
9237 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
018d34a4
VP
9238 i + 1, 0);
9239 if (target_resources_ok == 0)
9240 error (_("No hardware breakpoint support in the target."));
9241 else if (target_resources_ok < 0)
9242 error (_("Hardware breakpoints used exceeds limit."));
9243 }
9244
6c95b8df
PA
9245 gdb_assert (sals.nelts > 0);
9246
0d381245
VP
9247 for (i = 0; i < sals.nelts; ++i)
9248 {
9249 struct symtab_and_line sal = sals.sals[i];
9250 struct bp_location *loc;
9251
9252 if (from_tty)
5af949e3
UW
9253 {
9254 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9255 if (!loc_gdbarch)
9256 loc_gdbarch = gdbarch;
9257
9258 describe_other_breakpoints (loc_gdbarch,
6c95b8df 9259 sal.pspace, sal.pc, sal.section, thread);
5af949e3 9260 }
0d381245
VP
9261
9262 if (i == 0)
9263 {
d9b3f62e 9264 init_raw_breakpoint (b, gdbarch, sal, type, ops);
0d381245 9265 b->thread = thread;
4a306c9a 9266 b->task = task;
855a6e68 9267
0d381245 9268 b->cond_string = cond_string;
e7e0cddf 9269 b->extra_string = extra_string;
0d381245 9270 b->ignore_count = ignore_count;
41447f92 9271 b->enable_state = enabled ? bp_enabled : bp_disabled;
0d381245 9272 b->disposition = disposition;
6c95b8df 9273
44f238bb
PA
9274 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9275 b->loc->inserted = 1;
9276
0fb4aa4b
PA
9277 if (type == bp_static_tracepoint)
9278 {
d9b3f62e 9279 struct tracepoint *t = (struct tracepoint *) b;
0fb4aa4b
PA
9280 struct static_tracepoint_marker marker;
9281
983af33b 9282 if (strace_marker_p (b))
0fb4aa4b
PA
9283 {
9284 /* We already know the marker exists, otherwise, we
9285 wouldn't see a sal for it. */
d28cd78a
TT
9286 const char *p
9287 = &event_location_to_string (b->location.get ())[3];
f00aae0f 9288 const char *endp;
0fb4aa4b 9289 char *marker_str;
0fb4aa4b 9290
f00aae0f 9291 p = skip_spaces_const (p);
0fb4aa4b 9292
f00aae0f 9293 endp = skip_to_space_const (p);
0fb4aa4b
PA
9294
9295 marker_str = savestring (p, endp - p);
d9b3f62e 9296 t->static_trace_marker_id = marker_str;
0fb4aa4b 9297
3e43a32a
MS
9298 printf_filtered (_("Probed static tracepoint "
9299 "marker \"%s\"\n"),
d9b3f62e 9300 t->static_trace_marker_id);
0fb4aa4b
PA
9301 }
9302 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
9303 {
d9b3f62e 9304 t->static_trace_marker_id = xstrdup (marker.str_id);
0fb4aa4b
PA
9305 release_static_tracepoint_marker (&marker);
9306
3e43a32a
MS
9307 printf_filtered (_("Probed static tracepoint "
9308 "marker \"%s\"\n"),
d9b3f62e 9309 t->static_trace_marker_id);
0fb4aa4b
PA
9310 }
9311 else
3e43a32a
MS
9312 warning (_("Couldn't determine the static "
9313 "tracepoint marker to probe"));
0fb4aa4b
PA
9314 }
9315
0d381245
VP
9316 loc = b->loc;
9317 }
9318 else
018d34a4 9319 {
39d61571 9320 loc = add_location_to_breakpoint (b, &sal);
44f238bb
PA
9321 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9322 loc->inserted = 1;
0d381245
VP
9323 }
9324
9325 if (b->cond_string)
9326 {
bbc13ae3
KS
9327 const char *arg = b->cond_string;
9328
1bb9788d
TT
9329 loc->cond = parse_exp_1 (&arg, loc->address,
9330 block_for_pc (loc->address), 0);
0d381245 9331 if (*arg)
588ae58c 9332 error (_("Garbage '%s' follows condition"), arg);
018d34a4 9333 }
e7e0cddf
SS
9334
9335 /* Dynamic printf requires and uses additional arguments on the
9336 command line, otherwise it's an error. */
9337 if (type == bp_dprintf)
9338 {
9339 if (b->extra_string)
9340 update_dprintf_command_list (b);
9341 else
9342 error (_("Format string required"));
9343 }
9344 else if (b->extra_string)
588ae58c 9345 error (_("Garbage '%s' at end of command"), b->extra_string);
855a6e68 9346 }
018d34a4 9347
56435ebe 9348 b->display_canonical = display_canonical;
f00aae0f 9349 if (location != NULL)
d28cd78a 9350 b->location = std::move (location);
018d34a4 9351 else
d28cd78a 9352 b->location = new_address_location (b->loc->address, NULL, 0);
f8eba3c6 9353 b->filter = filter;
d9b3f62e 9354}
018d34a4 9355
d9b3f62e
PA
9356static void
9357create_breakpoint_sal (struct gdbarch *gdbarch,
f00aae0f 9358 struct symtabs_and_lines sals,
ffc2605c 9359 event_location_up &&location,
f8eba3c6 9360 char *filter, char *cond_string,
e7e0cddf 9361 char *extra_string,
d9b3f62e
PA
9362 enum bptype type, enum bpdisp disposition,
9363 int thread, int task, int ignore_count,
c0a91b2b 9364 const struct breakpoint_ops *ops, int from_tty,
44f238bb
PA
9365 int enabled, int internal, unsigned flags,
9366 int display_canonical)
d9b3f62e
PA
9367{
9368 struct breakpoint *b;
9369 struct cleanup *old_chain;
9370
9371 if (is_tracepoint_type (type))
9372 {
9373 struct tracepoint *t;
9374
4d01a485 9375 t = new tracepoint ();
d9b3f62e
PA
9376 b = &t->base;
9377 }
9378 else
4d01a485 9379 b = new breakpoint ();
d9b3f62e
PA
9380
9381 old_chain = make_cleanup (xfree, b);
9382
9383 init_breakpoint_sal (b, gdbarch,
ffc2605c 9384 sals, std::move (location),
e7e0cddf 9385 filter, cond_string, extra_string,
d9b3f62e
PA
9386 type, disposition,
9387 thread, task, ignore_count,
9388 ops, from_tty,
44f238bb
PA
9389 enabled, internal, flags,
9390 display_canonical);
d9b3f62e
PA
9391 discard_cleanups (old_chain);
9392
3ea46bff 9393 install_breakpoint (internal, b, 0);
018d34a4
VP
9394}
9395
9396/* Add SALS.nelts breakpoints to the breakpoint table. For each
9397 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9398 value. COND_STRING, if not NULL, specified the condition to be
9399 used for all breakpoints. Essentially the only case where
9400 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9401 function. In that case, it's still not possible to specify
9402 separate conditions for different overloaded functions, so
9403 we take just a single condition string.
9404
c3f6f71d 9405 NOTE: If the function succeeds, the caller is expected to cleanup
018d34a4 9406 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
c3f6f71d
JM
9407 array contents). If the function fails (error() is called), the
9408 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4a64f543 9409 COND and SALS arrays and each of those arrays contents. */
c906108c
SS
9410
9411static void
8cdf0e15 9412create_breakpoints_sal (struct gdbarch *gdbarch,
7efd8fc2 9413 struct linespec_result *canonical,
e7e0cddf 9414 char *cond_string, char *extra_string,
8cdf0e15
VP
9415 enum bptype type, enum bpdisp disposition,
9416 int thread, int task, int ignore_count,
c0a91b2b 9417 const struct breakpoint_ops *ops, int from_tty,
44f238bb 9418 int enabled, int internal, unsigned flags)
c906108c 9419{
018d34a4 9420 int i;
f8eba3c6 9421 struct linespec_sals *lsal;
cc59ec59 9422
f8eba3c6
TT
9423 if (canonical->pre_expanded)
9424 gdb_assert (VEC_length (linespec_sals, canonical->sals) == 1);
9425
9426 for (i = 0; VEC_iterate (linespec_sals, canonical->sals, i, lsal); ++i)
c3f6f71d 9427 {
f00aae0f 9428 /* Note that 'location' can be NULL in the case of a plain
f8eba3c6 9429 'break', without arguments. */
ffc2605c 9430 event_location_up location
f00aae0f 9431 = (canonical->location != NULL
8e9e35b1 9432 ? copy_event_location (canonical->location.get ()) : NULL);
f8eba3c6 9433 char *filter_string = lsal->canonical ? xstrdup (lsal->canonical) : NULL;
0d381245 9434
f8eba3c6
TT
9435 make_cleanup (xfree, filter_string);
9436 create_breakpoint_sal (gdbarch, lsal->sals,
ffc2605c 9437 std::move (location),
f8eba3c6 9438 filter_string,
e7e0cddf
SS
9439 cond_string, extra_string,
9440 type, disposition,
84f4c1fe 9441 thread, task, ignore_count, ops,
44f238bb 9442 from_tty, enabled, internal, flags,
56435ebe 9443 canonical->special_display);
c3f6f71d 9444 }
c3f6f71d 9445}
c906108c 9446
f00aae0f 9447/* Parse LOCATION which is assumed to be a SAL specification possibly
c3f6f71d 9448 followed by conditionals. On return, SALS contains an array of SAL
f00aae0f
KS
9449 addresses found. LOCATION points to the end of the SAL (for
9450 linespec locations).
9998af43
TJB
9451
9452 The array and the line spec strings are allocated on the heap, it is
9453 the caller's responsibility to free them. */
c906108c 9454
b9362cc7 9455static void
f00aae0f 9456parse_breakpoint_sals (const struct event_location *location,
58438ac1 9457 struct linespec_result *canonical)
c3f6f71d 9458{
f00aae0f
KS
9459 struct symtab_and_line cursal;
9460
9461 if (event_location_type (location) == LINESPEC_LOCATION)
9462 {
9463 const char *address = get_linespec_location (location);
9464
9465 if (address == NULL)
9466 {
9467 /* The last displayed codepoint, if it's valid, is our default
9468 breakpoint address. */
9469 if (last_displayed_sal_is_valid ())
9470 {
9471 struct linespec_sals lsal;
9472 struct symtab_and_line sal;
9473 CORE_ADDR pc;
9474
9475 init_sal (&sal); /* Initialize to zeroes. */
8d749320 9476 lsal.sals.sals = XNEW (struct symtab_and_line);
f00aae0f
KS
9477
9478 /* Set sal's pspace, pc, symtab, and line to the values
9479 corresponding to the last call to print_frame_info.
9480 Be sure to reinitialize LINE with NOTCURRENT == 0
9481 as the breakpoint line number is inappropriate otherwise.
9482 find_pc_line would adjust PC, re-set it back. */
9483 get_last_displayed_sal (&sal);
9484 pc = sal.pc;
9485 sal = find_pc_line (pc, 0);
9486
9487 /* "break" without arguments is equivalent to "break *PC"
9488 where PC is the last displayed codepoint's address. So
9489 make sure to set sal.explicit_pc to prevent GDB from
9490 trying to expand the list of sals to include all other
9491 instances with the same symtab and line. */
9492 sal.pc = pc;
9493 sal.explicit_pc = 1;
9494
9495 lsal.sals.sals[0] = sal;
9496 lsal.sals.nelts = 1;
9497 lsal.canonical = NULL;
9498
9499 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
9500 return;
9501 }
9502 else
9503 error (_("No default breakpoint address now."));
c906108c 9504 }
c906108c 9505 }
f00aae0f
KS
9506
9507 /* Force almost all breakpoints to be in terms of the
9508 current_source_symtab (which is decode_line_1's default).
9509 This should produce the results we want almost all of the
9510 time while leaving default_breakpoint_* alone.
9511
9512 ObjC: However, don't match an Objective-C method name which
9513 may have a '+' or '-' succeeded by a '['. */
9514 cursal = get_current_source_symtab_and_line ();
9515 if (last_displayed_sal_is_valid ())
c906108c 9516 {
f00aae0f 9517 const char *address = NULL;
cc80f267 9518
f00aae0f
KS
9519 if (event_location_type (location) == LINESPEC_LOCATION)
9520 address = get_linespec_location (location);
cc80f267 9521
f00aae0f
KS
9522 if (!cursal.symtab
9523 || (address != NULL
9524 && strchr ("+-", address[0]) != NULL
9525 && address[1] != '['))
9526 {
c2f4122d 9527 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
f00aae0f
KS
9528 get_last_displayed_symtab (),
9529 get_last_displayed_line (),
9530 canonical, NULL, NULL);
9531 return;
9532 }
c906108c 9533 }
f00aae0f 9534
c2f4122d 9535 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, NULL,
f00aae0f 9536 cursal.symtab, cursal.line, canonical, NULL, NULL);
c3f6f71d 9537}
c906108c 9538
c906108c 9539
c3f6f71d 9540/* Convert each SAL into a real PC. Verify that the PC can be
4a64f543 9541 inserted as a breakpoint. If it can't throw an error. */
c906108c 9542
b9362cc7 9543static void
23e7acfb 9544breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
c3f6f71d
JM
9545{
9546 int i;
cc59ec59 9547
c3f6f71d 9548 for (i = 0; i < sals->nelts; i++)
ee53e872 9549 resolve_sal_pc (&sals->sals[i]);
c3f6f71d
JM
9550}
9551
7a697b8d
SS
9552/* Fast tracepoints may have restrictions on valid locations. For
9553 instance, a fast tracepoint using a jump instead of a trap will
9554 likely have to overwrite more bytes than a trap would, and so can
9555 only be placed where the instruction is longer than the jump, or a
9556 multi-instruction sequence does not have a jump into the middle of
9557 it, etc. */
9558
9559static void
9560check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9561 struct symtabs_and_lines *sals)
9562{
9563 int i, rslt;
9564 struct symtab_and_line *sal;
9565 char *msg;
9566 struct cleanup *old_chain;
9567
9568 for (i = 0; i < sals->nelts; i++)
9569 {
f8eba3c6
TT
9570 struct gdbarch *sarch;
9571
7a697b8d
SS
9572 sal = &sals->sals[i];
9573
f8eba3c6
TT
9574 sarch = get_sal_arch (*sal);
9575 /* We fall back to GDBARCH if there is no architecture
9576 associated with SAL. */
9577 if (sarch == NULL)
9578 sarch = gdbarch;
6b940e6a 9579 rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal->pc, &msg);
7a697b8d
SS
9580 old_chain = make_cleanup (xfree, msg);
9581
9582 if (!rslt)
53c3572a 9583 error (_("May not have a fast tracepoint at %s%s"),
f8eba3c6 9584 paddress (sarch, sal->pc), (msg ? msg : ""));
7a697b8d
SS
9585
9586 do_cleanups (old_chain);
9587 }
9588}
9589
018d34a4
VP
9590/* Given TOK, a string specification of condition and thread, as
9591 accepted by the 'break' command, extract the condition
9592 string and thread number and set *COND_STRING and *THREAD.
4a64f543 9593 PC identifies the context at which the condition should be parsed.
018d34a4
VP
9594 If no condition is found, *COND_STRING is set to NULL.
9595 If no thread is found, *THREAD is set to -1. */
d634f2de
JB
9596
9597static void
bbc13ae3 9598find_condition_and_thread (const char *tok, CORE_ADDR pc,
e7e0cddf
SS
9599 char **cond_string, int *thread, int *task,
9600 char **rest)
018d34a4
VP
9601{
9602 *cond_string = NULL;
9603 *thread = -1;
ed1d1739
KS
9604 *task = 0;
9605 *rest = NULL;
9606
018d34a4
VP
9607 while (tok && *tok)
9608 {
bbc13ae3 9609 const char *end_tok;
018d34a4 9610 int toklen;
bbc13ae3
KS
9611 const char *cond_start = NULL;
9612 const char *cond_end = NULL;
cc59ec59 9613
bbc13ae3 9614 tok = skip_spaces_const (tok);
e7e0cddf
SS
9615
9616 if ((*tok == '"' || *tok == ',') && rest)
9617 {
9618 *rest = savestring (tok, strlen (tok));
9619 return;
9620 }
9621
bbc13ae3 9622 end_tok = skip_to_space_const (tok);
d634f2de 9623
018d34a4 9624 toklen = end_tok - tok;
d634f2de 9625
018d34a4
VP
9626 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9627 {
9628 tok = cond_start = end_tok + 1;
4d01a485 9629 parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
018d34a4 9630 cond_end = tok;
d634f2de 9631 *cond_string = savestring (cond_start, cond_end - cond_start);
018d34a4
VP
9632 }
9633 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9634 {
5d5658a1
PA
9635 const char *tmptok;
9636 struct thread_info *thr;
d634f2de 9637
018d34a4 9638 tok = end_tok + 1;
5d5658a1 9639 thr = parse_thread_id (tok, &tmptok);
018d34a4
VP
9640 if (tok == tmptok)
9641 error (_("Junk after thread keyword."));
5d5658a1 9642 *thread = thr->global_num;
bbc13ae3 9643 tok = tmptok;
018d34a4 9644 }
4a306c9a
JB
9645 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9646 {
9647 char *tmptok;
9648
9649 tok = end_tok + 1;
bbc13ae3 9650 *task = strtol (tok, &tmptok, 0);
4a306c9a
JB
9651 if (tok == tmptok)
9652 error (_("Junk after task keyword."));
9653 if (!valid_task_id (*task))
b6199126 9654 error (_("Unknown task %d."), *task);
bbc13ae3 9655 tok = tmptok;
4a306c9a 9656 }
e7e0cddf
SS
9657 else if (rest)
9658 {
9659 *rest = savestring (tok, strlen (tok));
ccab2054 9660 return;
e7e0cddf 9661 }
018d34a4
VP
9662 else
9663 error (_("Junk at end of arguments."));
9664 }
9665}
9666
0fb4aa4b
PA
9667/* Decode a static tracepoint marker spec. */
9668
9669static struct symtabs_and_lines
f00aae0f 9670decode_static_tracepoint_spec (const char **arg_p)
0fb4aa4b
PA
9671{
9672 VEC(static_tracepoint_marker_p) *markers = NULL;
9673 struct symtabs_and_lines sals;
0fb4aa4b 9674 struct cleanup *old_chain;
f00aae0f
KS
9675 const char *p = &(*arg_p)[3];
9676 const char *endp;
0fb4aa4b
PA
9677 char *marker_str;
9678 int i;
9679
f00aae0f 9680 p = skip_spaces_const (p);
0fb4aa4b 9681
f00aae0f 9682 endp = skip_to_space_const (p);
0fb4aa4b
PA
9683
9684 marker_str = savestring (p, endp - p);
9685 old_chain = make_cleanup (xfree, marker_str);
9686
9687 markers = target_static_tracepoint_markers_by_strid (marker_str);
9688 if (VEC_empty(static_tracepoint_marker_p, markers))
9689 error (_("No known static tracepoint marker named %s"), marker_str);
9690
9691 sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
8d749320 9692 sals.sals = XNEWVEC (struct symtab_and_line, sals.nelts);
0fb4aa4b
PA
9693
9694 for (i = 0; i < sals.nelts; i++)
9695 {
9696 struct static_tracepoint_marker *marker;
9697
9698 marker = VEC_index (static_tracepoint_marker_p, markers, i);
9699
9700 init_sal (&sals.sals[i]);
9701
9702 sals.sals[i] = find_pc_line (marker->address, 0);
9703 sals.sals[i].pc = marker->address;
9704
9705 release_static_tracepoint_marker (marker);
9706 }
9707
9708 do_cleanups (old_chain);
9709
9710 *arg_p = endp;
9711 return sals;
9712}
9713
f00aae0f 9714/* See breakpoint.h. */
0101ce28 9715
8cdf0e15
VP
9716int
9717create_breakpoint (struct gdbarch *gdbarch,
f00aae0f 9718 const struct event_location *location, char *cond_string,
e7e0cddf 9719 int thread, char *extra_string,
f00aae0f 9720 int parse_extra,
0fb4aa4b 9721 int tempflag, enum bptype type_wanted,
8cdf0e15
VP
9722 int ignore_count,
9723 enum auto_boolean pending_break_support,
c0a91b2b 9724 const struct breakpoint_ops *ops,
44f238bb
PA
9725 int from_tty, int enabled, int internal,
9726 unsigned flags)
c3f6f71d 9727{
7efd8fc2 9728 struct linespec_result canonical;
80c99de1 9729 struct cleanup *bkpt_chain = NULL;
0101ce28 9730 int pending = 0;
4a306c9a 9731 int task = 0;
86b17b60 9732 int prev_bkpt_count = breakpoint_count;
c3f6f71d 9733
348d480f
PA
9734 gdb_assert (ops != NULL);
9735
f00aae0f
KS
9736 /* If extra_string isn't useful, set it to NULL. */
9737 if (extra_string != NULL && *extra_string == '\0')
9738 extra_string = NULL;
9739
492d29ea 9740 TRY
b78a6381 9741 {
f00aae0f 9742 ops->create_sals_from_location (location, &canonical, type_wanted);
b78a6381 9743 }
492d29ea 9744 CATCH (e, RETURN_MASK_ERROR)
0101ce28 9745 {
492d29ea
PA
9746 /* If caller is interested in rc value from parse, set
9747 value. */
9748 if (e.error == NOT_FOUND_ERROR)
0101ce28 9749 {
05ff989b
AC
9750 /* If pending breakpoint support is turned off, throw
9751 error. */
fa8d40ab
JJ
9752
9753 if (pending_break_support == AUTO_BOOLEAN_FALSE)
723a2275
VP
9754 throw_exception (e);
9755
9756 exception_print (gdb_stderr, e);
fa8d40ab 9757
05ff989b
AC
9758 /* If pending breakpoint support is auto query and the user
9759 selects no, then simply return the error code. */
059fb39f 9760 if (pending_break_support == AUTO_BOOLEAN_AUTO
bfccc43c
YQ
9761 && !nquery (_("Make %s pending on future shared library load? "),
9762 bptype_string (type_wanted)))
fd9b8c24 9763 return 0;
fa8d40ab 9764
05ff989b
AC
9765 /* At this point, either the user was queried about setting
9766 a pending breakpoint and selected yes, or pending
9767 breakpoint behavior is on and thus a pending breakpoint
9768 is defaulted on behalf of the user. */
f00aae0f 9769 pending = 1;
0101ce28 9770 }
492d29ea
PA
9771 else
9772 throw_exception (e);
0101ce28 9773 }
492d29ea
PA
9774 END_CATCH
9775
f00aae0f 9776 if (!pending && VEC_empty (linespec_sals, canonical.sals))
492d29ea 9777 return 0;
c3f6f71d 9778
c3f6f71d
JM
9779 /* ----------------------------- SNIP -----------------------------
9780 Anything added to the cleanup chain beyond this point is assumed
9781 to be part of a breakpoint. If the breakpoint create succeeds
80c99de1
PA
9782 then the memory is not reclaimed. */
9783 bkpt_chain = make_cleanup (null_cleanup, 0);
c3f6f71d 9784
c3f6f71d
JM
9785 /* Resolve all line numbers to PC's and verify that the addresses
9786 are ok for the target. */
0101ce28 9787 if (!pending)
f8eba3c6
TT
9788 {
9789 int ix;
9790 struct linespec_sals *iter;
9791
9792 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9793 breakpoint_sals_to_pc (&iter->sals);
9794 }
c3f6f71d 9795
7a697b8d 9796 /* Fast tracepoints may have additional restrictions on location. */
bfccc43c 9797 if (!pending && type_wanted == bp_fast_tracepoint)
f8eba3c6
TT
9798 {
9799 int ix;
9800 struct linespec_sals *iter;
9801
9802 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9803 check_fast_tracepoint_sals (gdbarch, &iter->sals);
9804 }
7a697b8d 9805
c3f6f71d
JM
9806 /* Verify that condition can be parsed, before setting any
9807 breakpoints. Allocate a separate condition expression for each
4a64f543 9808 breakpoint. */
0101ce28 9809 if (!pending)
c3f6f71d 9810 {
f00aae0f 9811 if (parse_extra)
72b2ff0e 9812 {
0878d0fa 9813 char *rest;
52d361e1
YQ
9814 struct linespec_sals *lsal;
9815
9816 lsal = VEC_index (linespec_sals, canonical.sals, 0);
9817
0878d0fa
YQ
9818 /* Here we only parse 'arg' to separate condition
9819 from thread number, so parsing in context of first
9820 sal is OK. When setting the breakpoint we'll
9821 re-parse it in context of each sal. */
9822
f00aae0f
KS
9823 find_condition_and_thread (extra_string, lsal->sals.sals[0].pc,
9824 &cond_string, &thread, &task, &rest);
0878d0fa
YQ
9825 if (cond_string)
9826 make_cleanup (xfree, cond_string);
9827 if (rest)
9828 make_cleanup (xfree, rest);
9829 if (rest)
9830 extra_string = rest;
f00aae0f
KS
9831 else
9832 extra_string = NULL;
72b2ff0e 9833 }
2f069f6f 9834 else
72b2ff0e 9835 {
f00aae0f
KS
9836 if (type_wanted != bp_dprintf
9837 && extra_string != NULL && *extra_string != '\0')
9838 error (_("Garbage '%s' at end of location"), extra_string);
0878d0fa
YQ
9839
9840 /* Create a private copy of condition string. */
9841 if (cond_string)
9842 {
9843 cond_string = xstrdup (cond_string);
9844 make_cleanup (xfree, cond_string);
9845 }
9846 /* Create a private copy of any extra string. */
9847 if (extra_string)
9848 {
9849 extra_string = xstrdup (extra_string);
9850 make_cleanup (xfree, extra_string);
9851 }
72b2ff0e 9852 }
0fb4aa4b 9853
52d361e1 9854 ops->create_breakpoints_sal (gdbarch, &canonical,
e7e0cddf 9855 cond_string, extra_string, type_wanted,
d9b3f62e
PA
9856 tempflag ? disp_del : disp_donttouch,
9857 thread, task, ignore_count, ops,
44f238bb 9858 from_tty, enabled, internal, flags);
c906108c 9859 }
0101ce28
JJ
9860 else
9861 {
0101ce28
JJ
9862 struct breakpoint *b;
9863
bfccc43c
YQ
9864 if (is_tracepoint_type (type_wanted))
9865 {
9866 struct tracepoint *t;
9867
4d01a485 9868 t = new tracepoint ();
bfccc43c
YQ
9869 b = &t->base;
9870 }
9871 else
4d01a485 9872 b = new breakpoint ();
bfccc43c
YQ
9873
9874 init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops);
d28cd78a 9875 b->location = copy_event_location (location);
bfccc43c 9876
f00aae0f
KS
9877 if (parse_extra)
9878 b->cond_string = NULL;
e12c7713
MK
9879 else
9880 {
9881 /* Create a private copy of condition string. */
9882 if (cond_string)
9883 {
9884 cond_string = xstrdup (cond_string);
9885 make_cleanup (xfree, cond_string);
9886 }
9887 b->cond_string = cond_string;
15630549 9888 b->thread = thread;
e12c7713 9889 }
f00aae0f
KS
9890
9891 /* Create a private copy of any extra string. */
9892 if (extra_string != NULL)
9893 {
9894 extra_string = xstrdup (extra_string);
9895 make_cleanup (xfree, extra_string);
9896 }
9897 b->extra_string = extra_string;
0101ce28 9898 b->ignore_count = ignore_count;
0101ce28 9899 b->disposition = tempflag ? disp_del : disp_donttouch;
0d381245 9900 b->condition_not_parsed = 1;
41447f92 9901 b->enable_state = enabled ? bp_enabled : bp_disabled;
cc72b2a2
KP
9902 if ((type_wanted != bp_breakpoint
9903 && type_wanted != bp_hardware_breakpoint) || thread != -1)
f8eba3c6 9904 b->pspace = current_program_space;
8bea4e01 9905
bfccc43c 9906 install_breakpoint (internal, b, 0);
0101ce28
JJ
9907 }
9908
f8eba3c6 9909 if (VEC_length (linespec_sals, canonical.sals) > 1)
95a42b64 9910 {
3e43a32a
MS
9911 warning (_("Multiple breakpoints were set.\nUse the "
9912 "\"delete\" command to delete unwanted breakpoints."));
86b17b60 9913 prev_breakpoint_count = prev_bkpt_count;
95a42b64
TT
9914 }
9915
80c99de1
PA
9916 /* That's it. Discard the cleanups for data inserted into the
9917 breakpoint. */
9918 discard_cleanups (bkpt_chain);
217dc9e2 9919
80c99de1 9920 /* error call may happen here - have BKPT_CHAIN already discarded. */
44702360 9921 update_global_location_list (UGLL_MAY_INSERT);
fd9b8c24
PA
9922
9923 return 1;
c3f6f71d 9924}
c906108c 9925
348d480f 9926/* Set a breakpoint.
72b2ff0e
VP
9927 ARG is a string describing breakpoint address,
9928 condition, and thread.
9929 FLAG specifies if a breakpoint is hardware on,
9930 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9931 and BP_TEMPFLAG. */
348d480f 9932
98deb0da 9933static void
72b2ff0e 9934break_command_1 (char *arg, int flag, int from_tty)
c3f6f71d 9935{
72b2ff0e 9936 int tempflag = flag & BP_TEMPFLAG;
0fb4aa4b
PA
9937 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9938 ? bp_hardware_breakpoint
9939 : bp_breakpoint);
55aa24fb 9940 struct breakpoint_ops *ops;
f00aae0f 9941
ffc2605c 9942 event_location_up location = string_to_event_location (&arg, current_language);
55aa24fb
SDJ
9943
9944 /* Matching breakpoints on probes. */
5b56227b 9945 if (location != NULL
ffc2605c 9946 && event_location_type (location.get ()) == PROBE_LOCATION)
55aa24fb
SDJ
9947 ops = &bkpt_probe_breakpoint_ops;
9948 else
9949 ops = &bkpt_breakpoint_ops;
c3f6f71d 9950
8cdf0e15 9951 create_breakpoint (get_current_arch (),
ffc2605c 9952 location.get (),
f00aae0f 9953 NULL, 0, arg, 1 /* parse arg */,
0fb4aa4b 9954 tempflag, type_wanted,
8cdf0e15
VP
9955 0 /* Ignore count */,
9956 pending_break_support,
55aa24fb 9957 ops,
8cdf0e15 9958 from_tty,
84f4c1fe 9959 1 /* enabled */,
44f238bb
PA
9960 0 /* internal */,
9961 0);
c906108c
SS
9962}
9963
c906108c
SS
9964/* Helper function for break_command_1 and disassemble_command. */
9965
9966void
fba45db2 9967resolve_sal_pc (struct symtab_and_line *sal)
c906108c
SS
9968{
9969 CORE_ADDR pc;
9970
9971 if (sal->pc == 0 && sal->symtab != NULL)
9972 {
9973 if (!find_line_pc (sal->symtab, sal->line, &pc))
8a3fe4f8 9974 error (_("No line %d in file \"%s\"."),
05cba821 9975 sal->line, symtab_to_filename_for_display (sal->symtab));
c906108c 9976 sal->pc = pc;
6a048695 9977
4a64f543
MS
9978 /* If this SAL corresponds to a breakpoint inserted using a line
9979 number, then skip the function prologue if necessary. */
6a048695 9980 if (sal->explicit_line)
059acae7 9981 skip_prologue_sal (sal);
c906108c
SS
9982 }
9983
9984 if (sal->section == 0 && sal->symtab != NULL)
9985 {
346d1dfe 9986 const struct blockvector *bv;
3977b71f 9987 const struct block *b;
c5aa993b 9988 struct symbol *sym;
c906108c 9989
43f3e411
DE
9990 bv = blockvector_for_pc_sect (sal->pc, 0, &b,
9991 SYMTAB_COMPUNIT (sal->symtab));
c906108c
SS
9992 if (bv != NULL)
9993 {
7f0df278 9994 sym = block_linkage_function (b);
c906108c
SS
9995 if (sym != NULL)
9996 {
eb822aa6
DE
9997 fixup_symbol_section (sym, SYMTAB_OBJFILE (sal->symtab));
9998 sal->section = SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal->symtab),
9999 sym);
c906108c
SS
10000 }
10001 else
10002 {
4a64f543
MS
10003 /* It really is worthwhile to have the section, so we'll
10004 just have to look harder. This case can be executed
10005 if we have line numbers but no functions (as can
10006 happen in assembly source). */
c906108c 10007
7cbd4a93 10008 struct bound_minimal_symbol msym;
6c95b8df
PA
10009 struct cleanup *old_chain = save_current_space_and_thread ();
10010
10011 switch_to_program_space_and_thread (sal->pspace);
c906108c
SS
10012
10013 msym = lookup_minimal_symbol_by_pc (sal->pc);
7cbd4a93 10014 if (msym.minsym)
efd66ac6 10015 sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
6c95b8df
PA
10016
10017 do_cleanups (old_chain);
c906108c
SS
10018 }
10019 }
10020 }
10021}
10022
10023void
fba45db2 10024break_command (char *arg, int from_tty)
c906108c 10025{
db107f19 10026 break_command_1 (arg, 0, from_tty);
c906108c
SS
10027}
10028
c906108c 10029void
fba45db2 10030tbreak_command (char *arg, int from_tty)
c906108c 10031{
db107f19 10032 break_command_1 (arg, BP_TEMPFLAG, from_tty);
c906108c
SS
10033}
10034
c906108c 10035static void
fba45db2 10036hbreak_command (char *arg, int from_tty)
c906108c 10037{
db107f19 10038 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
c906108c
SS
10039}
10040
10041static void
fba45db2 10042thbreak_command (char *arg, int from_tty)
c906108c 10043{
db107f19 10044 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
c906108c
SS
10045}
10046
10047static void
fba45db2 10048stop_command (char *arg, int from_tty)
c906108c 10049{
a3f17187 10050 printf_filtered (_("Specify the type of breakpoint to set.\n\
c906108c 10051Usage: stop in <function | address>\n\
a3f17187 10052 stop at <line>\n"));
c906108c
SS
10053}
10054
10055static void
fba45db2 10056stopin_command (char *arg, int from_tty)
c906108c
SS
10057{
10058 int badInput = 0;
10059
c5aa993b 10060 if (arg == (char *) NULL)
c906108c
SS
10061 badInput = 1;
10062 else if (*arg != '*')
10063 {
10064 char *argptr = arg;
10065 int hasColon = 0;
10066
4a64f543 10067 /* Look for a ':'. If this is a line number specification, then
53a5351d 10068 say it is bad, otherwise, it should be an address or
4a64f543 10069 function/method name. */
c906108c 10070 while (*argptr && !hasColon)
c5aa993b
JM
10071 {
10072 hasColon = (*argptr == ':');
10073 argptr++;
10074 }
c906108c
SS
10075
10076 if (hasColon)
c5aa993b 10077 badInput = (*argptr != ':'); /* Not a class::method */
c906108c 10078 else
c5aa993b 10079 badInput = isdigit (*arg); /* a simple line number */
c906108c
SS
10080 }
10081
10082 if (badInput)
a3f17187 10083 printf_filtered (_("Usage: stop in <function | address>\n"));
c906108c 10084 else
db107f19 10085 break_command_1 (arg, 0, from_tty);
c906108c
SS
10086}
10087
10088static void
fba45db2 10089stopat_command (char *arg, int from_tty)
c906108c
SS
10090{
10091 int badInput = 0;
10092
c5aa993b 10093 if (arg == (char *) NULL || *arg == '*') /* no line number */
c906108c
SS
10094 badInput = 1;
10095 else
10096 {
10097 char *argptr = arg;
10098 int hasColon = 0;
10099
4a64f543
MS
10100 /* Look for a ':'. If there is a '::' then get out, otherwise
10101 it is probably a line number. */
c906108c 10102 while (*argptr && !hasColon)
c5aa993b
JM
10103 {
10104 hasColon = (*argptr == ':');
10105 argptr++;
10106 }
c906108c
SS
10107
10108 if (hasColon)
c5aa993b 10109 badInput = (*argptr == ':'); /* we have class::method */
c906108c 10110 else
c5aa993b 10111 badInput = !isdigit (*arg); /* not a line number */
c906108c
SS
10112 }
10113
10114 if (badInput)
a3f17187 10115 printf_filtered (_("Usage: stop at <line>\n"));
c906108c 10116 else
db107f19 10117 break_command_1 (arg, 0, from_tty);
c906108c
SS
10118}
10119
e7e0cddf
SS
10120/* The dynamic printf command is mostly like a regular breakpoint, but
10121 with a prewired command list consisting of a single output command,
10122 built from extra arguments supplied on the dprintf command
10123 line. */
10124
da821c7b 10125static void
e7e0cddf
SS
10126dprintf_command (char *arg, int from_tty)
10127{
ffc2605c 10128 event_location_up location = string_to_event_location (&arg, current_language);
f00aae0f
KS
10129
10130 /* If non-NULL, ARG should have been advanced past the location;
10131 the next character must be ','. */
10132 if (arg != NULL)
10133 {
10134 if (arg[0] != ',' || arg[1] == '\0')
10135 error (_("Format string required"));
10136 else
10137 {
10138 /* Skip the comma. */
10139 ++arg;
10140 }
10141 }
10142
e7e0cddf 10143 create_breakpoint (get_current_arch (),
ffc2605c 10144 location.get (),
f00aae0f 10145 NULL, 0, arg, 1 /* parse arg */,
e7e0cddf
SS
10146 0, bp_dprintf,
10147 0 /* Ignore count */,
10148 pending_break_support,
10149 &dprintf_breakpoint_ops,
10150 from_tty,
10151 1 /* enabled */,
10152 0 /* internal */,
10153 0);
10154}
10155
d3ce09f5
SS
10156static void
10157agent_printf_command (char *arg, int from_tty)
10158{
10159 error (_("May only run agent-printf on the target"));
10160}
10161
f1310107
TJB
10162/* Implement the "breakpoint_hit" breakpoint_ops method for
10163 ranged breakpoints. */
10164
10165static int
10166breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
10167 struct address_space *aspace,
09ac7c10
TT
10168 CORE_ADDR bp_addr,
10169 const struct target_waitstatus *ws)
f1310107 10170{
09ac7c10 10171 if (ws->kind != TARGET_WAITKIND_STOPPED
a493e3e2 10172 || ws->value.sig != GDB_SIGNAL_TRAP)
09ac7c10
TT
10173 return 0;
10174
f1310107
TJB
10175 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
10176 bl->length, aspace, bp_addr);
10177}
10178
10179/* Implement the "resources_needed" breakpoint_ops method for
10180 ranged breakpoints. */
10181
10182static int
10183resources_needed_ranged_breakpoint (const struct bp_location *bl)
10184{
10185 return target_ranged_break_num_registers ();
10186}
10187
10188/* Implement the "print_it" breakpoint_ops method for
10189 ranged breakpoints. */
10190
10191static enum print_stop_action
348d480f 10192print_it_ranged_breakpoint (bpstat bs)
f1310107 10193{
348d480f 10194 struct breakpoint *b = bs->breakpoint_at;
f1310107 10195 struct bp_location *bl = b->loc;
79a45e25 10196 struct ui_out *uiout = current_uiout;
f1310107
TJB
10197
10198 gdb_assert (b->type == bp_hardware_breakpoint);
10199
10200 /* Ranged breakpoints have only one location. */
10201 gdb_assert (bl && bl->next == NULL);
10202
10203 annotate_breakpoint (b->number);
f303dbd6
PA
10204
10205 maybe_print_thread_hit_breakpoint (uiout);
10206
f1310107 10207 if (b->disposition == disp_del)
112e8700 10208 uiout->text ("Temporary ranged breakpoint ");
f1310107 10209 else
112e8700
SM
10210 uiout->text ("Ranged breakpoint ");
10211 if (uiout->is_mi_like_p ())
f1310107 10212 {
112e8700 10213 uiout->field_string ("reason",
f1310107 10214 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
112e8700 10215 uiout->field_string ("disp", bpdisp_text (b->disposition));
f1310107 10216 }
112e8700
SM
10217 uiout->field_int ("bkptno", b->number);
10218 uiout->text (", ");
f1310107
TJB
10219
10220 return PRINT_SRC_AND_LOC;
10221}
10222
10223/* Implement the "print_one" breakpoint_ops method for
10224 ranged breakpoints. */
10225
10226static void
10227print_one_ranged_breakpoint (struct breakpoint *b,
10228 struct bp_location **last_loc)
10229{
10230 struct bp_location *bl = b->loc;
10231 struct value_print_options opts;
79a45e25 10232 struct ui_out *uiout = current_uiout;
f1310107
TJB
10233
10234 /* Ranged breakpoints have only one location. */
10235 gdb_assert (bl && bl->next == NULL);
10236
10237 get_user_print_options (&opts);
10238
10239 if (opts.addressprint)
10240 /* We don't print the address range here, it will be printed later
10241 by print_one_detail_ranged_breakpoint. */
112e8700 10242 uiout->field_skip ("addr");
f1310107
TJB
10243 annotate_field (5);
10244 print_breakpoint_location (b, bl);
10245 *last_loc = bl;
10246}
10247
10248/* Implement the "print_one_detail" breakpoint_ops method for
10249 ranged breakpoints. */
10250
10251static void
10252print_one_detail_ranged_breakpoint (const struct breakpoint *b,
10253 struct ui_out *uiout)
10254{
10255 CORE_ADDR address_start, address_end;
10256 struct bp_location *bl = b->loc;
d7e74731 10257 string_file stb;
f1310107
TJB
10258
10259 gdb_assert (bl);
10260
10261 address_start = bl->address;
10262 address_end = address_start + bl->length - 1;
10263
112e8700 10264 uiout->text ("\taddress range: ");
d7e74731
PA
10265 stb.printf ("[%s, %s]",
10266 print_core_address (bl->gdbarch, address_start),
10267 print_core_address (bl->gdbarch, address_end));
112e8700
SM
10268 uiout->field_stream ("addr", stb);
10269 uiout->text ("\n");
f1310107
TJB
10270}
10271
10272/* Implement the "print_mention" breakpoint_ops method for
10273 ranged breakpoints. */
10274
10275static void
10276print_mention_ranged_breakpoint (struct breakpoint *b)
10277{
10278 struct bp_location *bl = b->loc;
79a45e25 10279 struct ui_out *uiout = current_uiout;
f1310107
TJB
10280
10281 gdb_assert (bl);
10282 gdb_assert (b->type == bp_hardware_breakpoint);
10283
112e8700 10284 if (uiout->is_mi_like_p ())
f1310107
TJB
10285 return;
10286
10287 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10288 b->number, paddress (bl->gdbarch, bl->address),
10289 paddress (bl->gdbarch, bl->address + bl->length - 1));
10290}
10291
10292/* Implement the "print_recreate" breakpoint_ops method for
10293 ranged breakpoints. */
10294
10295static void
10296print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
10297{
f00aae0f 10298 fprintf_unfiltered (fp, "break-range %s, %s",
d28cd78a
TT
10299 event_location_to_string (b->location.get ()),
10300 event_location_to_string (b->location_range_end.get ()));
d9b3f62e 10301 print_recreate_thread (b, fp);
f1310107
TJB
10302}
10303
10304/* The breakpoint_ops structure to be used in ranged breakpoints. */
10305
2060206e 10306static struct breakpoint_ops ranged_breakpoint_ops;
f1310107
TJB
10307
10308/* Find the address where the end of the breakpoint range should be
10309 placed, given the SAL of the end of the range. This is so that if
10310 the user provides a line number, the end of the range is set to the
10311 last instruction of the given line. */
10312
10313static CORE_ADDR
10314find_breakpoint_range_end (struct symtab_and_line sal)
10315{
10316 CORE_ADDR end;
10317
10318 /* If the user provided a PC value, use it. Otherwise,
10319 find the address of the end of the given location. */
10320 if (sal.explicit_pc)
10321 end = sal.pc;
10322 else
10323 {
10324 int ret;
10325 CORE_ADDR start;
10326
10327 ret = find_line_pc_range (sal, &start, &end);
10328 if (!ret)
10329 error (_("Could not find location of the end of the range."));
10330
10331 /* find_line_pc_range returns the start of the next line. */
10332 end--;
10333 }
10334
10335 return end;
10336}
10337
10338/* Implement the "break-range" CLI command. */
10339
10340static void
10341break_range_command (char *arg, int from_tty)
10342{
870f88f7 10343 char *arg_start, *addr_string_start;
f1310107
TJB
10344 struct linespec_result canonical_start, canonical_end;
10345 int bp_count, can_use_bp, length;
10346 CORE_ADDR end;
10347 struct breakpoint *b;
10348 struct symtab_and_line sal_start, sal_end;
f1310107 10349 struct cleanup *cleanup_bkpt;
f8eba3c6 10350 struct linespec_sals *lsal_start, *lsal_end;
f1310107
TJB
10351
10352 /* We don't support software ranged breakpoints. */
10353 if (target_ranged_break_num_registers () < 0)
10354 error (_("This target does not support hardware ranged breakpoints."));
10355
10356 bp_count = hw_breakpoint_used_count ();
10357 bp_count += target_ranged_break_num_registers ();
10358 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
10359 bp_count, 0);
10360 if (can_use_bp < 0)
10361 error (_("Hardware breakpoints used exceeds limit."));
10362
f8eba3c6 10363 arg = skip_spaces (arg);
f1310107
TJB
10364 if (arg == NULL || arg[0] == '\0')
10365 error(_("No address range specified."));
10366
f8eba3c6 10367 arg_start = arg;
ffc2605c
TT
10368 event_location_up start_location = string_to_event_location (&arg,
10369 current_language);
10370 parse_breakpoint_sals (start_location.get (), &canonical_start);
f1310107
TJB
10371
10372 if (arg[0] != ',')
10373 error (_("Too few arguments."));
f8eba3c6 10374 else if (VEC_empty (linespec_sals, canonical_start.sals))
f1310107 10375 error (_("Could not find location of the beginning of the range."));
f8eba3c6
TT
10376
10377 lsal_start = VEC_index (linespec_sals, canonical_start.sals, 0);
10378
10379 if (VEC_length (linespec_sals, canonical_start.sals) > 1
10380 || lsal_start->sals.nelts != 1)
f1310107
TJB
10381 error (_("Cannot create a ranged breakpoint with multiple locations."));
10382
f8eba3c6
TT
10383 sal_start = lsal_start->sals.sals[0];
10384 addr_string_start = savestring (arg_start, arg - arg_start);
16e802b9 10385 cleanup_bkpt = make_cleanup (xfree, addr_string_start);
f1310107
TJB
10386
10387 arg++; /* Skip the comma. */
f8eba3c6 10388 arg = skip_spaces (arg);
f1310107
TJB
10389
10390 /* Parse the end location. */
10391
f1310107
TJB
10392 arg_start = arg;
10393
f8eba3c6 10394 /* We call decode_line_full directly here instead of using
f1310107
TJB
10395 parse_breakpoint_sals because we need to specify the start location's
10396 symtab and line as the default symtab and line for the end of the
10397 range. This makes it possible to have ranges like "foo.c:27, +14",
10398 where +14 means 14 lines from the start location. */
ffc2605c
TT
10399 event_location_up end_location = string_to_event_location (&arg,
10400 current_language);
10401 decode_line_full (end_location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
f8eba3c6
TT
10402 sal_start.symtab, sal_start.line,
10403 &canonical_end, NULL, NULL);
10404
f8eba3c6 10405 if (VEC_empty (linespec_sals, canonical_end.sals))
f1310107 10406 error (_("Could not find location of the end of the range."));
f8eba3c6
TT
10407
10408 lsal_end = VEC_index (linespec_sals, canonical_end.sals, 0);
10409 if (VEC_length (linespec_sals, canonical_end.sals) > 1
10410 || lsal_end->sals.nelts != 1)
f1310107
TJB
10411 error (_("Cannot create a ranged breakpoint with multiple locations."));
10412
f8eba3c6 10413 sal_end = lsal_end->sals.sals[0];
f1310107
TJB
10414
10415 end = find_breakpoint_range_end (sal_end);
10416 if (sal_start.pc > end)
177b42fe 10417 error (_("Invalid address range, end precedes start."));
f1310107
TJB
10418
10419 length = end - sal_start.pc + 1;
10420 if (length < 0)
10421 /* Length overflowed. */
10422 error (_("Address range too large."));
10423 else if (length == 1)
10424 {
10425 /* This range is simple enough to be handled by
10426 the `hbreak' command. */
10427 hbreak_command (addr_string_start, 1);
10428
10429 do_cleanups (cleanup_bkpt);
10430
10431 return;
10432 }
10433
10434 /* Now set up the breakpoint. */
10435 b = set_raw_breakpoint (get_current_arch (), sal_start,
348d480f 10436 bp_hardware_breakpoint, &ranged_breakpoint_ops);
f1310107
TJB
10437 set_breakpoint_count (breakpoint_count + 1);
10438 b->number = breakpoint_count;
10439 b->disposition = disp_donttouch;
d28cd78a
TT
10440 b->location = std::move (start_location);
10441 b->location_range_end = std::move (end_location);
f1310107
TJB
10442 b->loc->length = length;
10443
f8eba3c6 10444 do_cleanups (cleanup_bkpt);
f1310107
TJB
10445
10446 mention (b);
8d3788bd 10447 observer_notify_breakpoint_created (b);
44702360 10448 update_global_location_list (UGLL_MAY_INSERT);
f1310107
TJB
10449}
10450
4a64f543
MS
10451/* Return non-zero if EXP is verified as constant. Returned zero
10452 means EXP is variable. Also the constant detection may fail for
10453 some constant expressions and in such case still falsely return
10454 zero. */
2e6e3d9c 10455
65d79d4b
SDJ
10456static int
10457watchpoint_exp_is_const (const struct expression *exp)
10458{
10459 int i = exp->nelts;
10460
10461 while (i > 0)
10462 {
10463 int oplenp, argsp;
10464
10465 /* We are only interested in the descriptor of each element. */
10466 operator_length (exp, i, &oplenp, &argsp);
10467 i -= oplenp;
10468
10469 switch (exp->elts[i].opcode)
10470 {
10471 case BINOP_ADD:
10472 case BINOP_SUB:
10473 case BINOP_MUL:
10474 case BINOP_DIV:
10475 case BINOP_REM:
10476 case BINOP_MOD:
10477 case BINOP_LSH:
10478 case BINOP_RSH:
10479 case BINOP_LOGICAL_AND:
10480 case BINOP_LOGICAL_OR:
10481 case BINOP_BITWISE_AND:
10482 case BINOP_BITWISE_IOR:
10483 case BINOP_BITWISE_XOR:
10484 case BINOP_EQUAL:
10485 case BINOP_NOTEQUAL:
10486 case BINOP_LESS:
10487 case BINOP_GTR:
10488 case BINOP_LEQ:
10489 case BINOP_GEQ:
10490 case BINOP_REPEAT:
10491 case BINOP_COMMA:
10492 case BINOP_EXP:
10493 case BINOP_MIN:
10494 case BINOP_MAX:
10495 case BINOP_INTDIV:
10496 case BINOP_CONCAT:
65d79d4b
SDJ
10497 case TERNOP_COND:
10498 case TERNOP_SLICE:
65d79d4b
SDJ
10499
10500 case OP_LONG:
10501 case OP_DOUBLE:
10502 case OP_DECFLOAT:
10503 case OP_LAST:
10504 case OP_COMPLEX:
10505 case OP_STRING:
65d79d4b
SDJ
10506 case OP_ARRAY:
10507 case OP_TYPE:
608b4967
TT
10508 case OP_TYPEOF:
10509 case OP_DECLTYPE:
6e72ca20 10510 case OP_TYPEID:
65d79d4b
SDJ
10511 case OP_NAME:
10512 case OP_OBJC_NSSTRING:
10513
10514 case UNOP_NEG:
10515 case UNOP_LOGICAL_NOT:
10516 case UNOP_COMPLEMENT:
10517 case UNOP_ADDR:
10518 case UNOP_HIGH:
aeaa2474 10519 case UNOP_CAST:
9eaf6705
TT
10520
10521 case UNOP_CAST_TYPE:
10522 case UNOP_REINTERPRET_CAST:
10523 case UNOP_DYNAMIC_CAST:
4a64f543
MS
10524 /* Unary, binary and ternary operators: We have to check
10525 their operands. If they are constant, then so is the
10526 result of that operation. For instance, if A and B are
10527 determined to be constants, then so is "A + B".
10528
10529 UNOP_IND is one exception to the rule above, because the
10530 value of *ADDR is not necessarily a constant, even when
10531 ADDR is. */
65d79d4b
SDJ
10532 break;
10533
10534 case OP_VAR_VALUE:
10535 /* Check whether the associated symbol is a constant.
4a64f543 10536
65d79d4b 10537 We use SYMBOL_CLASS rather than TYPE_CONST because it's
4a64f543
MS
10538 possible that a buggy compiler could mark a variable as
10539 constant even when it is not, and TYPE_CONST would return
10540 true in this case, while SYMBOL_CLASS wouldn't.
10541
10542 We also have to check for function symbols because they
10543 are always constant. */
65d79d4b
SDJ
10544 {
10545 struct symbol *s = exp->elts[i + 2].symbol;
10546
10547 if (SYMBOL_CLASS (s) != LOC_BLOCK
10548 && SYMBOL_CLASS (s) != LOC_CONST
10549 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10550 return 0;
10551 break;
10552 }
10553
10554 /* The default action is to return 0 because we are using
10555 the optimistic approach here: If we don't know something,
10556 then it is not a constant. */
10557 default:
10558 return 0;
10559 }
10560 }
10561
10562 return 1;
10563}
10564
3a5c3e22
PA
10565/* Implement the "dtor" breakpoint_ops method for watchpoints. */
10566
10567static void
10568dtor_watchpoint (struct breakpoint *self)
10569{
10570 struct watchpoint *w = (struct watchpoint *) self;
10571
3a5c3e22
PA
10572 xfree (w->exp_string);
10573 xfree (w->exp_string_reparse);
10574 value_free (w->val);
10575
10576 base_breakpoint_ops.dtor (self);
10577}
10578
348d480f
PA
10579/* Implement the "re_set" breakpoint_ops method for watchpoints. */
10580
10581static void
10582re_set_watchpoint (struct breakpoint *b)
10583{
3a5c3e22
PA
10584 struct watchpoint *w = (struct watchpoint *) b;
10585
348d480f
PA
10586 /* Watchpoint can be either on expression using entirely global
10587 variables, or it can be on local variables.
10588
10589 Watchpoints of the first kind are never auto-deleted, and even
10590 persist across program restarts. Since they can use variables
10591 from shared libraries, we need to reparse expression as libraries
10592 are loaded and unloaded.
10593
10594 Watchpoints on local variables can also change meaning as result
10595 of solib event. For example, if a watchpoint uses both a local
10596 and a global variables in expression, it's a local watchpoint,
10597 but unloading of a shared library will make the expression
10598 invalid. This is not a very common use case, but we still
10599 re-evaluate expression, to avoid surprises to the user.
10600
10601 Note that for local watchpoints, we re-evaluate it only if
10602 watchpoints frame id is still valid. If it's not, it means the
10603 watchpoint is out of scope and will be deleted soon. In fact,
10604 I'm not sure we'll ever be called in this case.
10605
10606 If a local watchpoint's frame id is still valid, then
3a5c3e22 10607 w->exp_valid_block is likewise valid, and we can safely use it.
348d480f 10608
3a5c3e22
PA
10609 Don't do anything about disabled watchpoints, since they will be
10610 reevaluated again when enabled. */
10611 update_watchpoint (w, 1 /* reparse */);
348d480f
PA
10612}
10613
77b06cd7
TJB
10614/* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10615
10616static int
10617insert_watchpoint (struct bp_location *bl)
10618{
3a5c3e22
PA
10619 struct watchpoint *w = (struct watchpoint *) bl->owner;
10620 int length = w->exact ? 1 : bl->length;
e09342b5
TJB
10621
10622 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
4d01a485 10623 w->cond_exp.get ());
77b06cd7
TJB
10624}
10625
10626/* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10627
10628static int
73971819 10629remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
77b06cd7 10630{
3a5c3e22
PA
10631 struct watchpoint *w = (struct watchpoint *) bl->owner;
10632 int length = w->exact ? 1 : bl->length;
e09342b5
TJB
10633
10634 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
4d01a485 10635 w->cond_exp.get ());
e09342b5
TJB
10636}
10637
e09342b5 10638static int
348d480f 10639breakpoint_hit_watchpoint (const struct bp_location *bl,
09ac7c10
TT
10640 struct address_space *aspace, CORE_ADDR bp_addr,
10641 const struct target_waitstatus *ws)
e09342b5 10642{
348d480f 10643 struct breakpoint *b = bl->owner;
3a5c3e22 10644 struct watchpoint *w = (struct watchpoint *) b;
77b06cd7 10645
348d480f
PA
10646 /* Continuable hardware watchpoints are treated as non-existent if the
10647 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10648 some data address). Otherwise gdb won't stop on a break instruction
10649 in the code (not from a breakpoint) when a hardware watchpoint has
10650 been defined. Also skip watchpoints which we know did not trigger
10651 (did not match the data address). */
10652 if (is_hardware_watchpoint (b)
3a5c3e22 10653 && w->watchpoint_triggered == watch_triggered_no)
348d480f 10654 return 0;
9c06b0b4 10655
348d480f 10656 return 1;
9c06b0b4
TJB
10657}
10658
348d480f
PA
10659static void
10660check_status_watchpoint (bpstat bs)
9c06b0b4 10661{
348d480f 10662 gdb_assert (is_watchpoint (bs->breakpoint_at));
9c06b0b4 10663
348d480f 10664 bpstat_check_watchpoint (bs);
9c06b0b4
TJB
10665}
10666
10667/* Implement the "resources_needed" breakpoint_ops method for
348d480f 10668 hardware watchpoints. */
9c06b0b4
TJB
10669
10670static int
348d480f 10671resources_needed_watchpoint (const struct bp_location *bl)
9c06b0b4 10672{
3a5c3e22
PA
10673 struct watchpoint *w = (struct watchpoint *) bl->owner;
10674 int length = w->exact? 1 : bl->length;
348d480f
PA
10675
10676 return target_region_ok_for_hw_watchpoint (bl->address, length);
9c06b0b4
TJB
10677}
10678
10679/* Implement the "works_in_software_mode" breakpoint_ops method for
348d480f 10680 hardware watchpoints. */
9c06b0b4
TJB
10681
10682static int
348d480f 10683works_in_software_mode_watchpoint (const struct breakpoint *b)
9c06b0b4 10684{
efa80663
PA
10685 /* Read and access watchpoints only work with hardware support. */
10686 return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
9c06b0b4
TJB
10687}
10688
9c06b0b4 10689static enum print_stop_action
348d480f 10690print_it_watchpoint (bpstat bs)
9c06b0b4 10691{
348d480f
PA
10692 struct cleanup *old_chain;
10693 struct breakpoint *b;
348d480f 10694 enum print_stop_action result;
3a5c3e22 10695 struct watchpoint *w;
79a45e25 10696 struct ui_out *uiout = current_uiout;
348d480f
PA
10697
10698 gdb_assert (bs->bp_location_at != NULL);
10699
348d480f 10700 b = bs->breakpoint_at;
3a5c3e22 10701 w = (struct watchpoint *) b;
348d480f 10702
d7e74731 10703 old_chain = make_cleanup (null_cleanup, NULL);
9c06b0b4 10704
f303dbd6
PA
10705 annotate_watchpoint (b->number);
10706 maybe_print_thread_hit_breakpoint (uiout);
10707
d7e74731
PA
10708 string_file stb;
10709
9c06b0b4
TJB
10710 switch (b->type)
10711 {
348d480f 10712 case bp_watchpoint:
9c06b0b4 10713 case bp_hardware_watchpoint:
112e8700
SM
10714 if (uiout->is_mi_like_p ())
10715 uiout->field_string
10716 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
348d480f
PA
10717 mention (b);
10718 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
112e8700 10719 uiout->text ("\nOld value = ");
d7e74731 10720 watchpoint_value_print (bs->old_val, &stb);
112e8700
SM
10721 uiout->field_stream ("old", stb);
10722 uiout->text ("\nNew value = ");
d7e74731 10723 watchpoint_value_print (w->val, &stb);
112e8700
SM
10724 uiout->field_stream ("new", stb);
10725 uiout->text ("\n");
348d480f
PA
10726 /* More than one watchpoint may have been triggered. */
10727 result = PRINT_UNKNOWN;
9c06b0b4
TJB
10728 break;
10729
10730 case bp_read_watchpoint:
112e8700
SM
10731 if (uiout->is_mi_like_p ())
10732 uiout->field_string
10733 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
348d480f
PA
10734 mention (b);
10735 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
112e8700 10736 uiout->text ("\nValue = ");
d7e74731 10737 watchpoint_value_print (w->val, &stb);
112e8700
SM
10738 uiout->field_stream ("value", stb);
10739 uiout->text ("\n");
348d480f 10740 result = PRINT_UNKNOWN;
9c06b0b4
TJB
10741 break;
10742
10743 case bp_access_watchpoint:
348d480f
PA
10744 if (bs->old_val != NULL)
10745 {
112e8700
SM
10746 if (uiout->is_mi_like_p ())
10747 uiout->field_string
10748 ("reason",
348d480f
PA
10749 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10750 mention (b);
10751 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
112e8700 10752 uiout->text ("\nOld value = ");
d7e74731 10753 watchpoint_value_print (bs->old_val, &stb);
112e8700
SM
10754 uiout->field_stream ("old", stb);
10755 uiout->text ("\nNew value = ");
348d480f
PA
10756 }
10757 else
10758 {
10759 mention (b);
112e8700
SM
10760 if (uiout->is_mi_like_p ())
10761 uiout->field_string
10762 ("reason",
348d480f
PA
10763 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10764 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
112e8700 10765 uiout->text ("\nValue = ");
348d480f 10766 }
d7e74731 10767 watchpoint_value_print (w->val, &stb);
112e8700
SM
10768 uiout->field_stream ("new", stb);
10769 uiout->text ("\n");
348d480f 10770 result = PRINT_UNKNOWN;
9c06b0b4
TJB
10771 break;
10772 default:
348d480f 10773 result = PRINT_UNKNOWN;
9c06b0b4
TJB
10774 }
10775
348d480f
PA
10776 do_cleanups (old_chain);
10777 return result;
10778}
10779
10780/* Implement the "print_mention" breakpoint_ops method for hardware
10781 watchpoints. */
10782
10783static void
10784print_mention_watchpoint (struct breakpoint *b)
10785{
10786 struct cleanup *ui_out_chain;
3a5c3e22 10787 struct watchpoint *w = (struct watchpoint *) b;
79a45e25 10788 struct ui_out *uiout = current_uiout;
348d480f
PA
10789
10790 switch (b->type)
10791 {
10792 case bp_watchpoint:
112e8700 10793 uiout->text ("Watchpoint ");
348d480f
PA
10794 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10795 break;
10796 case bp_hardware_watchpoint:
112e8700 10797 uiout->text ("Hardware watchpoint ");
348d480f
PA
10798 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10799 break;
10800 case bp_read_watchpoint:
112e8700 10801 uiout->text ("Hardware read watchpoint ");
348d480f
PA
10802 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10803 break;
10804 case bp_access_watchpoint:
112e8700 10805 uiout->text ("Hardware access (read/write) watchpoint ");
348d480f
PA
10806 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10807 break;
10808 default:
10809 internal_error (__FILE__, __LINE__,
10810 _("Invalid hardware watchpoint type."));
10811 }
10812
112e8700
SM
10813 uiout->field_int ("number", b->number);
10814 uiout->text (": ");
10815 uiout->field_string ("exp", w->exp_string);
348d480f
PA
10816 do_cleanups (ui_out_chain);
10817}
10818
10819/* Implement the "print_recreate" breakpoint_ops method for
10820 watchpoints. */
10821
10822static void
10823print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10824{
3a5c3e22
PA
10825 struct watchpoint *w = (struct watchpoint *) b;
10826
348d480f
PA
10827 switch (b->type)
10828 {
10829 case bp_watchpoint:
10830 case bp_hardware_watchpoint:
10831 fprintf_unfiltered (fp, "watch");
10832 break;
10833 case bp_read_watchpoint:
10834 fprintf_unfiltered (fp, "rwatch");
10835 break;
10836 case bp_access_watchpoint:
10837 fprintf_unfiltered (fp, "awatch");
10838 break;
10839 default:
10840 internal_error (__FILE__, __LINE__,
10841 _("Invalid watchpoint type."));
10842 }
10843
3a5c3e22 10844 fprintf_unfiltered (fp, " %s", w->exp_string);
d9b3f62e 10845 print_recreate_thread (b, fp);
348d480f
PA
10846}
10847
427cd150
TT
10848/* Implement the "explains_signal" breakpoint_ops method for
10849 watchpoints. */
10850
47591c29 10851static int
427cd150
TT
10852explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10853{
10854 /* A software watchpoint cannot cause a signal other than
10855 GDB_SIGNAL_TRAP. */
10856 if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
47591c29 10857 return 0;
427cd150 10858
47591c29 10859 return 1;
427cd150
TT
10860}
10861
348d480f
PA
10862/* The breakpoint_ops structure to be used in hardware watchpoints. */
10863
2060206e 10864static struct breakpoint_ops watchpoint_breakpoint_ops;
348d480f
PA
10865
10866/* Implement the "insert" breakpoint_ops method for
10867 masked hardware watchpoints. */
10868
10869static int
10870insert_masked_watchpoint (struct bp_location *bl)
10871{
3a5c3e22
PA
10872 struct watchpoint *w = (struct watchpoint *) bl->owner;
10873
10874 return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
348d480f
PA
10875 bl->watchpoint_type);
10876}
10877
10878/* Implement the "remove" breakpoint_ops method for
10879 masked hardware watchpoints. */
10880
10881static int
73971819 10882remove_masked_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
348d480f 10883{
3a5c3e22
PA
10884 struct watchpoint *w = (struct watchpoint *) bl->owner;
10885
10886 return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
348d480f
PA
10887 bl->watchpoint_type);
10888}
10889
10890/* Implement the "resources_needed" breakpoint_ops method for
10891 masked hardware watchpoints. */
10892
10893static int
10894resources_needed_masked_watchpoint (const struct bp_location *bl)
10895{
3a5c3e22
PA
10896 struct watchpoint *w = (struct watchpoint *) bl->owner;
10897
10898 return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
348d480f
PA
10899}
10900
10901/* Implement the "works_in_software_mode" breakpoint_ops method for
10902 masked hardware watchpoints. */
10903
10904static int
10905works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10906{
10907 return 0;
10908}
10909
10910/* Implement the "print_it" breakpoint_ops method for
10911 masked hardware watchpoints. */
10912
10913static enum print_stop_action
10914print_it_masked_watchpoint (bpstat bs)
10915{
10916 struct breakpoint *b = bs->breakpoint_at;
79a45e25 10917 struct ui_out *uiout = current_uiout;
348d480f
PA
10918
10919 /* Masked watchpoints have only one location. */
10920 gdb_assert (b->loc && b->loc->next == NULL);
10921
f303dbd6
PA
10922 annotate_watchpoint (b->number);
10923 maybe_print_thread_hit_breakpoint (uiout);
10924
348d480f
PA
10925 switch (b->type)
10926 {
10927 case bp_hardware_watchpoint:
112e8700
SM
10928 if (uiout->is_mi_like_p ())
10929 uiout->field_string
10930 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
348d480f
PA
10931 break;
10932
10933 case bp_read_watchpoint:
112e8700
SM
10934 if (uiout->is_mi_like_p ())
10935 uiout->field_string
10936 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
348d480f
PA
10937 break;
10938
10939 case bp_access_watchpoint:
112e8700
SM
10940 if (uiout->is_mi_like_p ())
10941 uiout->field_string
10942 ("reason",
348d480f
PA
10943 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10944 break;
10945 default:
10946 internal_error (__FILE__, __LINE__,
10947 _("Invalid hardware watchpoint type."));
10948 }
10949
10950 mention (b);
112e8700 10951 uiout->text (_("\n\
9c06b0b4
TJB
10952Check the underlying instruction at PC for the memory\n\
10953address and value which triggered this watchpoint.\n"));
112e8700 10954 uiout->text ("\n");
9c06b0b4
TJB
10955
10956 /* More than one watchpoint may have been triggered. */
10957 return PRINT_UNKNOWN;
10958}
10959
10960/* Implement the "print_one_detail" breakpoint_ops method for
10961 masked hardware watchpoints. */
10962
10963static void
10964print_one_detail_masked_watchpoint (const struct breakpoint *b,
10965 struct ui_out *uiout)
10966{
3a5c3e22
PA
10967 struct watchpoint *w = (struct watchpoint *) b;
10968
9c06b0b4
TJB
10969 /* Masked watchpoints have only one location. */
10970 gdb_assert (b->loc && b->loc->next == NULL);
10971
112e8700
SM
10972 uiout->text ("\tmask ");
10973 uiout->field_core_addr ("mask", b->loc->gdbarch, w->hw_wp_mask);
10974 uiout->text ("\n");
9c06b0b4
TJB
10975}
10976
10977/* Implement the "print_mention" breakpoint_ops method for
10978 masked hardware watchpoints. */
10979
10980static void
10981print_mention_masked_watchpoint (struct breakpoint *b)
10982{
3a5c3e22 10983 struct watchpoint *w = (struct watchpoint *) b;
79a45e25 10984 struct ui_out *uiout = current_uiout;
9c06b0b4
TJB
10985 struct cleanup *ui_out_chain;
10986
10987 switch (b->type)
10988 {
10989 case bp_hardware_watchpoint:
112e8700 10990 uiout->text ("Masked hardware watchpoint ");
9c06b0b4
TJB
10991 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10992 break;
10993 case bp_read_watchpoint:
112e8700 10994 uiout->text ("Masked hardware read watchpoint ");
9c06b0b4
TJB
10995 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10996 break;
10997 case bp_access_watchpoint:
112e8700 10998 uiout->text ("Masked hardware access (read/write) watchpoint ");
9c06b0b4
TJB
10999 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
11000 break;
11001 default:
11002 internal_error (__FILE__, __LINE__,
11003 _("Invalid hardware watchpoint type."));
11004 }
11005
112e8700
SM
11006 uiout->field_int ("number", b->number);
11007 uiout->text (": ");
11008 uiout->field_string ("exp", w->exp_string);
9c06b0b4
TJB
11009 do_cleanups (ui_out_chain);
11010}
11011
11012/* Implement the "print_recreate" breakpoint_ops method for
11013 masked hardware watchpoints. */
11014
11015static void
11016print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
11017{
3a5c3e22 11018 struct watchpoint *w = (struct watchpoint *) b;
9c06b0b4
TJB
11019 char tmp[40];
11020
11021 switch (b->type)
11022 {
11023 case bp_hardware_watchpoint:
11024 fprintf_unfiltered (fp, "watch");
11025 break;
11026 case bp_read_watchpoint:
11027 fprintf_unfiltered (fp, "rwatch");
11028 break;
11029 case bp_access_watchpoint:
11030 fprintf_unfiltered (fp, "awatch");
11031 break;
11032 default:
11033 internal_error (__FILE__, __LINE__,
11034 _("Invalid hardware watchpoint type."));
11035 }
11036
3a5c3e22
PA
11037 sprintf_vma (tmp, w->hw_wp_mask);
11038 fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
d9b3f62e 11039 print_recreate_thread (b, fp);
9c06b0b4
TJB
11040}
11041
11042/* The breakpoint_ops structure to be used in masked hardware watchpoints. */
11043
2060206e 11044static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
9c06b0b4
TJB
11045
11046/* Tell whether the given watchpoint is a masked hardware watchpoint. */
11047
11048static int
11049is_masked_watchpoint (const struct breakpoint *b)
11050{
11051 return b->ops == &masked_watchpoint_breakpoint_ops;
11052}
11053
53a5351d
JM
11054/* accessflag: hw_write: watch write,
11055 hw_read: watch read,
11056 hw_access: watch access (read or write) */
c906108c 11057static void
bbc13ae3 11058watch_command_1 (const char *arg, int accessflag, int from_tty,
84f4c1fe 11059 int just_location, int internal)
c906108c 11060{
d983da9c 11061 struct breakpoint *b, *scope_breakpoint = NULL;
270140bd 11062 const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
a1442452 11063 struct value *val, *mark, *result;
bb9d5f81 11064 int saved_bitpos = 0, saved_bitsize = 0;
bbc13ae3
KS
11065 const char *exp_start = NULL;
11066 const char *exp_end = NULL;
11067 const char *tok, *end_tok;
9c06b0b4 11068 int toklen = -1;
bbc13ae3
KS
11069 const char *cond_start = NULL;
11070 const char *cond_end = NULL;
c906108c 11071 enum bptype bp_type;
37e4754d 11072 int thread = -1;
0cf6dd15 11073 int pc = 0;
9c06b0b4
TJB
11074 /* Flag to indicate whether we are going to use masks for
11075 the hardware watchpoint. */
11076 int use_mask = 0;
11077 CORE_ADDR mask = 0;
3a5c3e22 11078 struct watchpoint *w;
bbc13ae3
KS
11079 char *expression;
11080 struct cleanup *back_to;
c906108c 11081
37e4754d
LM
11082 /* Make sure that we actually have parameters to parse. */
11083 if (arg != NULL && arg[0] != '\0')
11084 {
bbc13ae3
KS
11085 const char *value_start;
11086
11087 exp_end = arg + strlen (arg);
37e4754d 11088
9c06b0b4
TJB
11089 /* Look for "parameter value" pairs at the end
11090 of the arguments string. */
bbc13ae3 11091 for (tok = exp_end - 1; tok > arg; tok--)
9c06b0b4
TJB
11092 {
11093 /* Skip whitespace at the end of the argument list. */
11094 while (tok > arg && (*tok == ' ' || *tok == '\t'))
11095 tok--;
11096
11097 /* Find the beginning of the last token.
11098 This is the value of the parameter. */
11099 while (tok > arg && (*tok != ' ' && *tok != '\t'))
11100 tok--;
11101 value_start = tok + 1;
11102
11103 /* Skip whitespace. */
11104 while (tok > arg && (*tok == ' ' || *tok == '\t'))
11105 tok--;
11106
11107 end_tok = tok;
11108
11109 /* Find the beginning of the second to last token.
11110 This is the parameter itself. */
11111 while (tok > arg && (*tok != ' ' && *tok != '\t'))
11112 tok--;
11113 tok++;
11114 toklen = end_tok - tok + 1;
11115
61012eef 11116 if (toklen == 6 && startswith (tok, "thread"))
9c06b0b4 11117 {
5d5658a1 11118 struct thread_info *thr;
9c06b0b4
TJB
11119 /* At this point we've found a "thread" token, which means
11120 the user is trying to set a watchpoint that triggers
11121 only in a specific thread. */
5d5658a1 11122 const char *endp;
37e4754d 11123
9c06b0b4
TJB
11124 if (thread != -1)
11125 error(_("You can specify only one thread."));
37e4754d 11126
9c06b0b4 11127 /* Extract the thread ID from the next token. */
5d5658a1 11128 thr = parse_thread_id (value_start, &endp);
37e4754d 11129
5d5658a1 11130 /* Check if the user provided a valid thread ID. */
9c06b0b4 11131 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
5d5658a1 11132 invalid_thread_id_error (value_start);
9c06b0b4 11133
5d5658a1 11134 thread = thr->global_num;
9c06b0b4 11135 }
61012eef 11136 else if (toklen == 4 && startswith (tok, "mask"))
9c06b0b4
TJB
11137 {
11138 /* We've found a "mask" token, which means the user wants to
11139 create a hardware watchpoint that is going to have the mask
11140 facility. */
11141 struct value *mask_value, *mark;
37e4754d 11142
9c06b0b4
TJB
11143 if (use_mask)
11144 error(_("You can specify only one mask."));
37e4754d 11145
9c06b0b4 11146 use_mask = just_location = 1;
37e4754d 11147
9c06b0b4
TJB
11148 mark = value_mark ();
11149 mask_value = parse_to_comma_and_eval (&value_start);
11150 mask = value_as_address (mask_value);
11151 value_free_to_mark (mark);
11152 }
11153 else
11154 /* We didn't recognize what we found. We should stop here. */
11155 break;
37e4754d 11156
9c06b0b4
TJB
11157 /* Truncate the string and get rid of the "parameter value" pair before
11158 the arguments string is parsed by the parse_exp_1 function. */
bbc13ae3 11159 exp_end = tok;
9c06b0b4 11160 }
37e4754d 11161 }
bbc13ae3
KS
11162 else
11163 exp_end = arg;
37e4754d 11164
bbc13ae3
KS
11165 /* Parse the rest of the arguments. From here on out, everything
11166 is in terms of a newly allocated string instead of the original
11167 ARG. */
c906108c 11168 innermost_block = NULL;
bbc13ae3
KS
11169 expression = savestring (arg, exp_end - arg);
11170 back_to = make_cleanup (xfree, expression);
11171 exp_start = arg = expression;
4d01a485 11172 expression_up exp = parse_exp_1 (&arg, 0, 0, 0);
c906108c 11173 exp_end = arg;
fa8a61dc
TT
11174 /* Remove trailing whitespace from the expression before saving it.
11175 This makes the eventual display of the expression string a bit
11176 prettier. */
11177 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
11178 --exp_end;
11179
65d79d4b 11180 /* Checking if the expression is not constant. */
4d01a485 11181 if (watchpoint_exp_is_const (exp.get ()))
65d79d4b
SDJ
11182 {
11183 int len;
11184
11185 len = exp_end - exp_start;
11186 while (len > 0 && isspace (exp_start[len - 1]))
11187 len--;
11188 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
11189 }
11190
c906108c
SS
11191 exp_valid_block = innermost_block;
11192 mark = value_mark ();
4d01a485 11193 fetch_subexp_value (exp.get (), &pc, &val, &result, NULL, just_location);
06a64a0b 11194
bb9d5f81
PP
11195 if (val != NULL && just_location)
11196 {
11197 saved_bitpos = value_bitpos (val);
11198 saved_bitsize = value_bitsize (val);
11199 }
11200
06a64a0b
TT
11201 if (just_location)
11202 {
9c06b0b4
TJB
11203 int ret;
11204
06a64a0b 11205 exp_valid_block = NULL;
a1442452 11206 val = value_addr (result);
06a64a0b
TT
11207 release_value (val);
11208 value_free_to_mark (mark);
9c06b0b4
TJB
11209
11210 if (use_mask)
11211 {
11212 ret = target_masked_watch_num_registers (value_as_address (val),
11213 mask);
11214 if (ret == -1)
11215 error (_("This target does not support masked watchpoints."));
11216 else if (ret == -2)
11217 error (_("Invalid mask or memory region."));
11218 }
06a64a0b
TT
11219 }
11220 else if (val != NULL)
fa4727a6 11221 release_value (val);
c906108c 11222
bbc13ae3
KS
11223 tok = skip_spaces_const (arg);
11224 end_tok = skip_to_space_const (tok);
c906108c
SS
11225
11226 toklen = end_tok - tok;
11227 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
11228 {
60e1c644 11229 innermost_block = NULL;
c906108c 11230 tok = cond_start = end_tok + 1;
4d01a485 11231 parse_exp_1 (&tok, 0, 0, 0);
60e1c644
PA
11232
11233 /* The watchpoint expression may not be local, but the condition
11234 may still be. E.g.: `watch global if local > 0'. */
11235 cond_exp_valid_block = innermost_block;
11236
c906108c
SS
11237 cond_end = tok;
11238 }
11239 if (*tok)
8a3fe4f8 11240 error (_("Junk at end of command."));
c906108c 11241
441d7c93
PA
11242 frame_info *wp_frame = block_innermost_frame (exp_valid_block);
11243
11244 /* Save this because create_internal_breakpoint below invalidates
11245 'wp_frame'. */
11246 frame_id watchpoint_frame = get_frame_id (wp_frame);
d983da9c
DJ
11247
11248 /* If the expression is "local", then set up a "watchpoint scope"
11249 breakpoint at the point where we've left the scope of the watchpoint
11250 expression. Create the scope breakpoint before the watchpoint, so
11251 that we will encounter it first in bpstat_stop_status. */
441d7c93 11252 if (exp_valid_block != NULL && wp_frame != NULL)
d983da9c 11253 {
441d7c93
PA
11254 frame_id caller_frame_id = frame_unwind_caller_id (wp_frame);
11255
11256 if (frame_id_p (caller_frame_id))
edb3359d 11257 {
441d7c93
PA
11258 gdbarch *caller_arch = frame_unwind_caller_arch (wp_frame);
11259 CORE_ADDR caller_pc = frame_unwind_caller_pc (wp_frame);
11260
edb3359d 11261 scope_breakpoint
441d7c93 11262 = create_internal_breakpoint (caller_arch, caller_pc,
06edf0c0
PA
11263 bp_watchpoint_scope,
11264 &momentary_breakpoint_ops);
d983da9c 11265
441d7c93
PA
11266 /* create_internal_breakpoint could invalidate WP_FRAME. */
11267 wp_frame = NULL;
11268
edb3359d 11269 scope_breakpoint->enable_state = bp_enabled;
d983da9c 11270
edb3359d
DJ
11271 /* Automatically delete the breakpoint when it hits. */
11272 scope_breakpoint->disposition = disp_del;
d983da9c 11273
edb3359d 11274 /* Only break in the proper frame (help with recursion). */
441d7c93 11275 scope_breakpoint->frame_id = caller_frame_id;
d983da9c 11276
edb3359d 11277 /* Set the address at which we will stop. */
441d7c93
PA
11278 scope_breakpoint->loc->gdbarch = caller_arch;
11279 scope_breakpoint->loc->requested_address = caller_pc;
edb3359d 11280 scope_breakpoint->loc->address
a6d9a66e
UW
11281 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
11282 scope_breakpoint->loc->requested_address,
edb3359d
DJ
11283 scope_breakpoint->type);
11284 }
d983da9c
DJ
11285 }
11286
e8369a73
AB
11287 /* Now set up the breakpoint. We create all watchpoints as hardware
11288 watchpoints here even if hardware watchpoints are turned off, a call
11289 to update_watchpoint later in this function will cause the type to
11290 drop back to bp_watchpoint (software watchpoint) if required. */
11291
11292 if (accessflag == hw_read)
11293 bp_type = bp_read_watchpoint;
11294 else if (accessflag == hw_access)
11295 bp_type = bp_access_watchpoint;
11296 else
11297 bp_type = bp_hardware_watchpoint;
3a5c3e22 11298
4d01a485 11299 w = new watchpoint ();
3a5c3e22 11300 b = &w->base;
348d480f 11301 if (use_mask)
3a5c3e22
PA
11302 init_raw_breakpoint_without_location (b, NULL, bp_type,
11303 &masked_watchpoint_breakpoint_ops);
348d480f 11304 else
3a5c3e22
PA
11305 init_raw_breakpoint_without_location (b, NULL, bp_type,
11306 &watchpoint_breakpoint_ops);
37e4754d 11307 b->thread = thread;
b5de0fa7 11308 b->disposition = disp_donttouch;
348d480f 11309 b->pspace = current_program_space;
b22e99fd 11310 w->exp = std::move (exp);
3a5c3e22
PA
11311 w->exp_valid_block = exp_valid_block;
11312 w->cond_exp_valid_block = cond_exp_valid_block;
06a64a0b
TT
11313 if (just_location)
11314 {
11315 struct type *t = value_type (val);
11316 CORE_ADDR addr = value_as_address (val);
06a64a0b
TT
11317
11318 t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
06a64a0b 11319
2f408ecb
PA
11320 std::string name = type_to_string (t);
11321
11322 w->exp_string_reparse = xstrprintf ("* (%s *) %s", name.c_str (),
d63d0675 11323 core_addr_to_string (addr));
06a64a0b 11324
3a5c3e22 11325 w->exp_string = xstrprintf ("-location %.*s",
d63d0675
JK
11326 (int) (exp_end - exp_start), exp_start);
11327
06a64a0b
TT
11328 /* The above expression is in C. */
11329 b->language = language_c;
11330 }
11331 else
3a5c3e22 11332 w->exp_string = savestring (exp_start, exp_end - exp_start);
9c06b0b4
TJB
11333
11334 if (use_mask)
11335 {
3a5c3e22 11336 w->hw_wp_mask = mask;
9c06b0b4
TJB
11337 }
11338 else
11339 {
3a5c3e22 11340 w->val = val;
bb9d5f81
PP
11341 w->val_bitpos = saved_bitpos;
11342 w->val_bitsize = saved_bitsize;
3a5c3e22 11343 w->val_valid = 1;
9c06b0b4 11344 }
77b06cd7 11345
c906108c
SS
11346 if (cond_start)
11347 b->cond_string = savestring (cond_start, cond_end - cond_start);
11348 else
11349 b->cond_string = 0;
c5aa993b 11350
441d7c93 11351 if (frame_id_p (watchpoint_frame))
f6bc2008 11352 {
441d7c93 11353 w->watchpoint_frame = watchpoint_frame;
3a5c3e22 11354 w->watchpoint_thread = inferior_ptid;
f6bc2008 11355 }
c906108c 11356 else
f6bc2008 11357 {
3a5c3e22
PA
11358 w->watchpoint_frame = null_frame_id;
11359 w->watchpoint_thread = null_ptid;
f6bc2008 11360 }
c906108c 11361
d983da9c 11362 if (scope_breakpoint != NULL)
c906108c 11363 {
d983da9c
DJ
11364 /* The scope breakpoint is related to the watchpoint. We will
11365 need to act on them together. */
11366 b->related_breakpoint = scope_breakpoint;
11367 scope_breakpoint->related_breakpoint = b;
c906108c 11368 }
d983da9c 11369
06a64a0b
TT
11370 if (!just_location)
11371 value_free_to_mark (mark);
2d134ed3 11372
492d29ea 11373 TRY
a9634178
TJB
11374 {
11375 /* Finally update the new watchpoint. This creates the locations
11376 that should be inserted. */
3a5c3e22 11377 update_watchpoint (w, 1);
a9634178 11378 }
492d29ea 11379 CATCH (e, RETURN_MASK_ALL)
a9634178
TJB
11380 {
11381 delete_breakpoint (b);
11382 throw_exception (e);
11383 }
492d29ea 11384 END_CATCH
a9634178 11385
3ea46bff 11386 install_breakpoint (internal, b, 1);
bbc13ae3 11387 do_cleanups (back_to);
c906108c
SS
11388}
11389
e09342b5 11390/* Return count of debug registers needed to watch the given expression.
e09342b5 11391 If the watchpoint cannot be handled in hardware return zero. */
c906108c 11392
c906108c 11393static int
a9634178 11394can_use_hardware_watchpoint (struct value *v)
c906108c
SS
11395{
11396 int found_memory_cnt = 0;
2e70b7b9 11397 struct value *head = v;
c906108c
SS
11398
11399 /* Did the user specifically forbid us to use hardware watchpoints? */
c5aa993b 11400 if (!can_use_hw_watchpoints)
c906108c 11401 return 0;
c5aa993b 11402
5c44784c
JM
11403 /* Make sure that the value of the expression depends only upon
11404 memory contents, and values computed from them within GDB. If we
11405 find any register references or function calls, we can't use a
11406 hardware watchpoint.
11407
11408 The idea here is that evaluating an expression generates a series
11409 of values, one holding the value of every subexpression. (The
11410 expression a*b+c has five subexpressions: a, b, a*b, c, and
11411 a*b+c.) GDB's values hold almost enough information to establish
11412 the criteria given above --- they identify memory lvalues,
11413 register lvalues, computed values, etcetera. So we can evaluate
11414 the expression, and then scan the chain of values that leaves
11415 behind to decide whether we can detect any possible change to the
11416 expression's final value using only hardware watchpoints.
11417
11418 However, I don't think that the values returned by inferior
11419 function calls are special in any way. So this function may not
11420 notice that an expression involving an inferior function call
11421 can't be watched with hardware watchpoints. FIXME. */
17cf0ecd 11422 for (; v; v = value_next (v))
c906108c 11423 {
5c44784c 11424 if (VALUE_LVAL (v) == lval_memory)
c906108c 11425 {
8464be76
DJ
11426 if (v != head && value_lazy (v))
11427 /* A lazy memory lvalue in the chain is one that GDB never
11428 needed to fetch; we either just used its address (e.g.,
11429 `a' in `a.b') or we never needed it at all (e.g., `a'
11430 in `a,b'). This doesn't apply to HEAD; if that is
11431 lazy then it was not readable, but watch it anyway. */
5c44784c 11432 ;
53a5351d 11433 else
5c44784c
JM
11434 {
11435 /* Ahh, memory we actually used! Check if we can cover
11436 it with hardware watchpoints. */
df407dfe 11437 struct type *vtype = check_typedef (value_type (v));
2e70b7b9
MS
11438
11439 /* We only watch structs and arrays if user asked for it
11440 explicitly, never if they just happen to appear in a
11441 middle of some value chain. */
11442 if (v == head
11443 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
11444 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
11445 {
42ae5230 11446 CORE_ADDR vaddr = value_address (v);
e09342b5
TJB
11447 int len;
11448 int num_regs;
11449
a9634178 11450 len = (target_exact_watchpoints
e09342b5
TJB
11451 && is_scalar_type_recursive (vtype))?
11452 1 : TYPE_LENGTH (value_type (v));
2e70b7b9 11453
e09342b5
TJB
11454 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
11455 if (!num_regs)
2e70b7b9
MS
11456 return 0;
11457 else
e09342b5 11458 found_memory_cnt += num_regs;
2e70b7b9 11459 }
5c44784c 11460 }
c5aa993b 11461 }
5086187c
AC
11462 else if (VALUE_LVAL (v) != not_lval
11463 && deprecated_value_modifiable (v) == 0)
38b6c3b3 11464 return 0; /* These are values from the history (e.g., $1). */
5086187c 11465 else if (VALUE_LVAL (v) == lval_register)
38b6c3b3 11466 return 0; /* Cannot watch a register with a HW watchpoint. */
c906108c
SS
11467 }
11468
11469 /* The expression itself looks suitable for using a hardware
11470 watchpoint, but give the target machine a chance to reject it. */
11471 return found_memory_cnt;
11472}
11473
8b93c638 11474void
84f4c1fe 11475watch_command_wrapper (char *arg, int from_tty, int internal)
8b93c638 11476{
84f4c1fe 11477 watch_command_1 (arg, hw_write, from_tty, 0, internal);
06a64a0b
TT
11478}
11479
06a64a0b
TT
11480/* A helper function that looks for the "-location" argument and then
11481 calls watch_command_1. */
11482
11483static void
11484watch_maybe_just_location (char *arg, int accessflag, int from_tty)
11485{
11486 int just_location = 0;
11487
11488 if (arg
11489 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11490 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11491 {
e9cafbcc 11492 arg = skip_spaces (arg);
06a64a0b
TT
11493 just_location = 1;
11494 }
11495
84f4c1fe 11496 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
8b93c638 11497}
8926118c 11498
c5aa993b 11499static void
fba45db2 11500watch_command (char *arg, int from_tty)
c906108c 11501{
06a64a0b 11502 watch_maybe_just_location (arg, hw_write, from_tty);
c906108c
SS
11503}
11504
8b93c638 11505void
84f4c1fe 11506rwatch_command_wrapper (char *arg, int from_tty, int internal)
8b93c638 11507{
84f4c1fe 11508 watch_command_1 (arg, hw_read, from_tty, 0, internal);
8b93c638 11509}
8926118c 11510
c5aa993b 11511static void
fba45db2 11512rwatch_command (char *arg, int from_tty)
c906108c 11513{
06a64a0b 11514 watch_maybe_just_location (arg, hw_read, from_tty);
c906108c
SS
11515}
11516
8b93c638 11517void
84f4c1fe 11518awatch_command_wrapper (char *arg, int from_tty, int internal)
8b93c638 11519{
84f4c1fe 11520 watch_command_1 (arg, hw_access, from_tty, 0, internal);
8b93c638 11521}
8926118c 11522
c5aa993b 11523static void
fba45db2 11524awatch_command (char *arg, int from_tty)
c906108c 11525{
06a64a0b 11526 watch_maybe_just_location (arg, hw_access, from_tty);
c906108c 11527}
c906108c 11528\f
c5aa993b 11529
cfc31633
PA
11530/* Data for the FSM that manages the until(location)/advance commands
11531 in infcmd.c. Here because it uses the mechanisms of
11532 breakpoints. */
c906108c 11533
cfc31633 11534struct until_break_fsm
bfec99b2 11535{
cfc31633
PA
11536 /* The base class. */
11537 struct thread_fsm thread_fsm;
11538
11539 /* The thread that as current when the command was executed. */
11540 int thread;
11541
11542 /* The breakpoint set at the destination location. */
11543 struct breakpoint *location_breakpoint;
11544
11545 /* Breakpoint set at the return address in the caller frame. May be
11546 NULL. */
11547 struct breakpoint *caller_breakpoint;
bfec99b2
PA
11548};
11549
8980e177
PA
11550static void until_break_fsm_clean_up (struct thread_fsm *self,
11551 struct thread_info *thread);
11552static int until_break_fsm_should_stop (struct thread_fsm *self,
11553 struct thread_info *thread);
cfc31633
PA
11554static enum async_reply_reason
11555 until_break_fsm_async_reply_reason (struct thread_fsm *self);
11556
11557/* until_break_fsm's vtable. */
11558
11559static struct thread_fsm_ops until_break_fsm_ops =
11560{
11561 NULL, /* dtor */
11562 until_break_fsm_clean_up,
11563 until_break_fsm_should_stop,
11564 NULL, /* return_value */
11565 until_break_fsm_async_reply_reason,
11566};
11567
11568/* Allocate a new until_break_command_fsm. */
11569
11570static struct until_break_fsm *
8980e177 11571new_until_break_fsm (struct interp *cmd_interp, int thread,
cfc31633
PA
11572 struct breakpoint *location_breakpoint,
11573 struct breakpoint *caller_breakpoint)
11574{
11575 struct until_break_fsm *sm;
11576
11577 sm = XCNEW (struct until_break_fsm);
8980e177 11578 thread_fsm_ctor (&sm->thread_fsm, &until_break_fsm_ops, cmd_interp);
cfc31633
PA
11579
11580 sm->thread = thread;
11581 sm->location_breakpoint = location_breakpoint;
11582 sm->caller_breakpoint = caller_breakpoint;
11583
11584 return sm;
11585}
11586
11587/* Implementation of the 'should_stop' FSM method for the
11588 until(location)/advance commands. */
11589
11590static int
8980e177
PA
11591until_break_fsm_should_stop (struct thread_fsm *self,
11592 struct thread_info *tp)
cfc31633
PA
11593{
11594 struct until_break_fsm *sm = (struct until_break_fsm *) self;
cfc31633
PA
11595
11596 if (bpstat_find_breakpoint (tp->control.stop_bpstat,
11597 sm->location_breakpoint) != NULL
11598 || (sm->caller_breakpoint != NULL
11599 && bpstat_find_breakpoint (tp->control.stop_bpstat,
11600 sm->caller_breakpoint) != NULL))
11601 thread_fsm_set_finished (self);
11602
11603 return 1;
11604}
11605
11606/* Implementation of the 'clean_up' FSM method for the
11607 until(location)/advance commands. */
11608
c2c6d25f 11609static void
8980e177
PA
11610until_break_fsm_clean_up (struct thread_fsm *self,
11611 struct thread_info *thread)
43ff13b4 11612{
cfc31633 11613 struct until_break_fsm *sm = (struct until_break_fsm *) self;
bfec99b2 11614
cfc31633
PA
11615 /* Clean up our temporary breakpoints. */
11616 if (sm->location_breakpoint != NULL)
11617 {
11618 delete_breakpoint (sm->location_breakpoint);
11619 sm->location_breakpoint = NULL;
11620 }
11621 if (sm->caller_breakpoint != NULL)
11622 {
11623 delete_breakpoint (sm->caller_breakpoint);
11624 sm->caller_breakpoint = NULL;
11625 }
11626 delete_longjmp_breakpoint (sm->thread);
11627}
11628
11629/* Implementation of the 'async_reply_reason' FSM method for the
11630 until(location)/advance commands. */
11631
11632static enum async_reply_reason
11633until_break_fsm_async_reply_reason (struct thread_fsm *self)
11634{
11635 return EXEC_ASYNC_LOCATION_REACHED;
43ff13b4
JM
11636}
11637
c906108c 11638void
ae66c1fc 11639until_break_command (char *arg, int from_tty, int anywhere)
c906108c
SS
11640{
11641 struct symtabs_and_lines sals;
11642 struct symtab_and_line sal;
8556afb4
PA
11643 struct frame_info *frame;
11644 struct gdbarch *frame_gdbarch;
11645 struct frame_id stack_frame_id;
11646 struct frame_id caller_frame_id;
cfc31633
PA
11647 struct breakpoint *location_breakpoint;
11648 struct breakpoint *caller_breakpoint = NULL;
ffc2605c 11649 struct cleanup *old_chain;
186c406b
TT
11650 int thread;
11651 struct thread_info *tp;
cfc31633 11652 struct until_break_fsm *sm;
c906108c 11653
70509625 11654 clear_proceed_status (0);
c906108c
SS
11655
11656 /* Set a breakpoint where the user wants it and at return from
4a64f543 11657 this function. */
c5aa993b 11658
ffc2605c 11659 event_location_up location = string_to_event_location (&arg, current_language);
f00aae0f 11660
1bfeeb0f 11661 if (last_displayed_sal_is_valid ())
ffc2605c 11662 sals = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE, NULL,
1bfeeb0f 11663 get_last_displayed_symtab (),
f8eba3c6 11664 get_last_displayed_line ());
c906108c 11665 else
ffc2605c 11666 sals = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
c2f4122d 11667 NULL, (struct symtab *) NULL, 0);
c5aa993b 11668
c906108c 11669 if (sals.nelts != 1)
8a3fe4f8 11670 error (_("Couldn't get information on specified line."));
c5aa993b 11671
c906108c 11672 sal = sals.sals[0];
4a64f543 11673 xfree (sals.sals); /* malloc'd, so freed. */
c5aa993b 11674
c906108c 11675 if (*arg)
8a3fe4f8 11676 error (_("Junk at end of arguments."));
c5aa993b 11677
c906108c 11678 resolve_sal_pc (&sal);
c5aa993b 11679
186c406b 11680 tp = inferior_thread ();
5d5658a1 11681 thread = tp->global_num;
186c406b 11682
883bc8d1
PA
11683 old_chain = make_cleanup (null_cleanup, NULL);
11684
8556afb4
PA
11685 /* Note linespec handling above invalidates the frame chain.
11686 Installing a breakpoint also invalidates the frame chain (as it
11687 may need to switch threads), so do any frame handling before
11688 that. */
11689
11690 frame = get_selected_frame (NULL);
11691 frame_gdbarch = get_frame_arch (frame);
11692 stack_frame_id = get_stack_frame_id (frame);
11693 caller_frame_id = frame_unwind_caller_id (frame);
883bc8d1 11694
ae66c1fc
EZ
11695 /* Keep within the current frame, or in frames called by the current
11696 one. */
edb3359d 11697
883bc8d1 11698 if (frame_id_p (caller_frame_id))
c906108c 11699 {
883bc8d1 11700 struct symtab_and_line sal2;
cfc31633 11701 struct gdbarch *caller_gdbarch;
883bc8d1
PA
11702
11703 sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11704 sal2.pc = frame_unwind_caller_pc (frame);
cfc31633
PA
11705 caller_gdbarch = frame_unwind_caller_arch (frame);
11706 caller_breakpoint = set_momentary_breakpoint (caller_gdbarch,
11707 sal2,
11708 caller_frame_id,
11709 bp_until);
11710 make_cleanup_delete_breakpoint (caller_breakpoint);
186c406b 11711
883bc8d1 11712 set_longjmp_breakpoint (tp, caller_frame_id);
186c406b 11713 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
c906108c 11714 }
c5aa993b 11715
c70a6932
JK
11716 /* set_momentary_breakpoint could invalidate FRAME. */
11717 frame = NULL;
11718
883bc8d1
PA
11719 if (anywhere)
11720 /* If the user told us to continue until a specified location,
11721 we don't specify a frame at which we need to stop. */
cfc31633
PA
11722 location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11723 null_frame_id, bp_until);
883bc8d1
PA
11724 else
11725 /* Otherwise, specify the selected frame, because we want to stop
11726 only at the very same frame. */
cfc31633
PA
11727 location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11728 stack_frame_id, bp_until);
11729 make_cleanup_delete_breakpoint (location_breakpoint);
883bc8d1 11730
8980e177 11731 sm = new_until_break_fsm (command_interp (), tp->global_num,
5d5658a1 11732 location_breakpoint, caller_breakpoint);
cfc31633 11733 tp->thread_fsm = &sm->thread_fsm;
f107f563 11734
cfc31633 11735 discard_cleanups (old_chain);
f107f563 11736
cfc31633 11737 proceed (-1, GDB_SIGNAL_DEFAULT);
c906108c 11738}
ae66c1fc 11739
c906108c
SS
11740/* This function attempts to parse an optional "if <cond>" clause
11741 from the arg string. If one is not found, it returns NULL.
c5aa993b 11742
c906108c
SS
11743 Else, it returns a pointer to the condition string. (It does not
11744 attempt to evaluate the string against a particular block.) And,
11745 it updates arg to point to the first character following the parsed
4a64f543 11746 if clause in the arg string. */
53a5351d 11747
63160a43
PA
11748const char *
11749ep_parse_optional_if_clause (const char **arg)
c906108c 11750{
63160a43 11751 const char *cond_string;
c5aa993b
JM
11752
11753 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
c906108c 11754 return NULL;
c5aa993b 11755
4a64f543 11756 /* Skip the "if" keyword. */
c906108c 11757 (*arg) += 2;
c5aa993b 11758
c906108c 11759 /* Skip any extra leading whitespace, and record the start of the
4a64f543 11760 condition string. */
63160a43 11761 *arg = skip_spaces_const (*arg);
c906108c 11762 cond_string = *arg;
c5aa993b 11763
4a64f543
MS
11764 /* Assume that the condition occupies the remainder of the arg
11765 string. */
c906108c 11766 (*arg) += strlen (cond_string);
c5aa993b 11767
c906108c
SS
11768 return cond_string;
11769}
c5aa993b 11770
c906108c
SS
11771/* Commands to deal with catching events, such as signals, exceptions,
11772 process start/exit, etc. */
c5aa993b
JM
11773
11774typedef enum
11775{
44feb3ce
TT
11776 catch_fork_temporary, catch_vfork_temporary,
11777 catch_fork_permanent, catch_vfork_permanent
c5aa993b
JM
11778}
11779catch_fork_kind;
11780
c906108c 11781static void
63160a43 11782catch_fork_command_1 (char *arg_entry, int from_tty,
cc59ec59 11783 struct cmd_list_element *command)
c906108c 11784{
63160a43 11785 const char *arg = arg_entry;
a6d9a66e 11786 struct gdbarch *gdbarch = get_current_arch ();
63160a43 11787 const char *cond_string = NULL;
44feb3ce
TT
11788 catch_fork_kind fork_kind;
11789 int tempflag;
11790
11791 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11792 tempflag = (fork_kind == catch_fork_temporary
11793 || fork_kind == catch_vfork_temporary);
c5aa993b 11794
44feb3ce
TT
11795 if (!arg)
11796 arg = "";
63160a43 11797 arg = skip_spaces_const (arg);
c5aa993b 11798
c906108c 11799 /* The allowed syntax is:
c5aa993b
JM
11800 catch [v]fork
11801 catch [v]fork if <cond>
11802
4a64f543 11803 First, check if there's an if clause. */
c906108c 11804 cond_string = ep_parse_optional_if_clause (&arg);
c5aa993b 11805
c906108c 11806 if ((*arg != '\0') && !isspace (*arg))
8a3fe4f8 11807 error (_("Junk at end of arguments."));
c5aa993b 11808
c906108c 11809 /* If this target supports it, create a fork or vfork catchpoint
4a64f543 11810 and enable reporting of such events. */
c5aa993b
JM
11811 switch (fork_kind)
11812 {
44feb3ce
TT
11813 case catch_fork_temporary:
11814 case catch_fork_permanent:
a6d9a66e 11815 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
ce78b96d 11816 &catch_fork_breakpoint_ops);
c906108c 11817 break;
44feb3ce
TT
11818 case catch_vfork_temporary:
11819 case catch_vfork_permanent:
a6d9a66e 11820 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
ce78b96d 11821 &catch_vfork_breakpoint_ops);
c906108c 11822 break;
c5aa993b 11823 default:
8a3fe4f8 11824 error (_("unsupported or unknown fork kind; cannot catch it"));
c906108c 11825 break;
c5aa993b 11826 }
c906108c
SS
11827}
11828
11829static void
63160a43 11830catch_exec_command_1 (char *arg_entry, int from_tty,
cc59ec59 11831 struct cmd_list_element *command)
c906108c 11832{
63160a43 11833 const char *arg = arg_entry;
b4d90040 11834 struct exec_catchpoint *c;
a6d9a66e 11835 struct gdbarch *gdbarch = get_current_arch ();
44feb3ce 11836 int tempflag;
63160a43 11837 const char *cond_string = NULL;
c906108c 11838
44feb3ce
TT
11839 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11840
11841 if (!arg)
11842 arg = "";
63160a43 11843 arg = skip_spaces_const (arg);
c906108c
SS
11844
11845 /* The allowed syntax is:
c5aa993b
JM
11846 catch exec
11847 catch exec if <cond>
c906108c 11848
4a64f543 11849 First, check if there's an if clause. */
c906108c
SS
11850 cond_string = ep_parse_optional_if_clause (&arg);
11851
11852 if ((*arg != '\0') && !isspace (*arg))
8a3fe4f8 11853 error (_("Junk at end of arguments."));
c906108c 11854
4d01a485 11855 c = new exec_catchpoint ();
b4d90040
PA
11856 init_catchpoint (&c->base, gdbarch, tempflag, cond_string,
11857 &catch_exec_breakpoint_ops);
11858 c->exec_pathname = NULL;
11859
3ea46bff 11860 install_breakpoint (0, &c->base, 1);
c906108c 11861}
c5aa993b 11862
9ac4176b 11863void
28010a5d
PA
11864init_ada_exception_breakpoint (struct breakpoint *b,
11865 struct gdbarch *gdbarch,
11866 struct symtab_and_line sal,
11867 char *addr_string,
c0a91b2b 11868 const struct breakpoint_ops *ops,
28010a5d 11869 int tempflag,
349774ef 11870 int enabled,
28010a5d 11871 int from_tty)
f7f9143b 11872{
f7f9143b
JB
11873 if (from_tty)
11874 {
5af949e3
UW
11875 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11876 if (!loc_gdbarch)
11877 loc_gdbarch = gdbarch;
11878
6c95b8df
PA
11879 describe_other_breakpoints (loc_gdbarch,
11880 sal.pspace, sal.pc, sal.section, -1);
f7f9143b
JB
11881 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11882 version for exception catchpoints, because two catchpoints
11883 used for different exception names will use the same address.
11884 In this case, a "breakpoint ... also set at..." warning is
4a64f543 11885 unproductive. Besides, the warning phrasing is also a bit
e5dd4106 11886 inappropriate, we should use the word catchpoint, and tell
f7f9143b
JB
11887 the user what type of catchpoint it is. The above is good
11888 enough for now, though. */
11889 }
11890
28010a5d 11891 init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
f7f9143b 11892
349774ef 11893 b->enable_state = enabled ? bp_enabled : bp_disabled;
f7f9143b 11894 b->disposition = tempflag ? disp_del : disp_donttouch;
d28cd78a
TT
11895 b->location = string_to_event_location (&addr_string,
11896 language_def (language_ada));
f7f9143b 11897 b->language = language_ada;
f7f9143b
JB
11898}
11899
c906108c 11900static void
fba45db2 11901catch_command (char *arg, int from_tty)
c906108c 11902{
44feb3ce 11903 error (_("Catch requires an event name."));
c906108c
SS
11904}
11905\f
11906
11907static void
fba45db2 11908tcatch_command (char *arg, int from_tty)
c906108c 11909{
44feb3ce 11910 error (_("Catch requires an event name."));
c906108c
SS
11911}
11912
8a2c437b
TT
11913/* A qsort comparison function that sorts breakpoints in order. */
11914
11915static int
11916compare_breakpoints (const void *a, const void *b)
11917{
9a3c8263 11918 const breakpoint_p *ba = (const breakpoint_p *) a;
8a2c437b 11919 uintptr_t ua = (uintptr_t) *ba;
9a3c8263 11920 const breakpoint_p *bb = (const breakpoint_p *) b;
8a2c437b
TT
11921 uintptr_t ub = (uintptr_t) *bb;
11922
11923 if ((*ba)->number < (*bb)->number)
11924 return -1;
11925 else if ((*ba)->number > (*bb)->number)
11926 return 1;
11927
11928 /* Now sort by address, in case we see, e..g, two breakpoints with
11929 the number 0. */
11930 if (ua < ub)
11931 return -1;
94b0e70d 11932 return ua > ub ? 1 : 0;
8a2c437b
TT
11933}
11934
80f8a6eb 11935/* Delete breakpoints by address or line. */
c906108c
SS
11936
11937static void
fba45db2 11938clear_command (char *arg, int from_tty)
c906108c 11939{
8a2c437b 11940 struct breakpoint *b, *prev;
d6e956e5
VP
11941 VEC(breakpoint_p) *found = 0;
11942 int ix;
c906108c
SS
11943 int default_match;
11944 struct symtabs_and_lines sals;
11945 struct symtab_and_line sal;
c906108c 11946 int i;
8a2c437b 11947 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
c906108c
SS
11948
11949 if (arg)
11950 {
39cf75f7
DE
11951 sals = decode_line_with_current_source (arg,
11952 (DECODE_LINE_FUNFIRSTLINE
11953 | DECODE_LINE_LIST_MODE));
cf4ded82 11954 make_cleanup (xfree, sals.sals);
c906108c
SS
11955 default_match = 0;
11956 }
11957 else
11958 {
8d749320 11959 sals.sals = XNEW (struct symtab_and_line);
80f8a6eb 11960 make_cleanup (xfree, sals.sals);
4a64f543 11961 init_sal (&sal); /* Initialize to zeroes. */
1bfeeb0f
JL
11962
11963 /* Set sal's line, symtab, pc, and pspace to the values
11964 corresponding to the last call to print_frame_info. If the
11965 codepoint is not valid, this will set all the fields to 0. */
11966 get_last_displayed_sal (&sal);
c906108c 11967 if (sal.symtab == 0)
8a3fe4f8 11968 error (_("No source file specified."));
c906108c
SS
11969
11970 sals.sals[0] = sal;
11971 sals.nelts = 1;
11972
11973 default_match = 1;
11974 }
11975
4a64f543
MS
11976 /* We don't call resolve_sal_pc here. That's not as bad as it
11977 seems, because all existing breakpoints typically have both
11978 file/line and pc set. So, if clear is given file/line, we can
11979 match this to existing breakpoint without obtaining pc at all.
ed0616c6
VP
11980
11981 We only support clearing given the address explicitly
11982 present in breakpoint table. Say, we've set breakpoint
4a64f543 11983 at file:line. There were several PC values for that file:line,
ed0616c6 11984 due to optimization, all in one block.
4a64f543
MS
11985
11986 We've picked one PC value. If "clear" is issued with another
ed0616c6
VP
11987 PC corresponding to the same file:line, the breakpoint won't
11988 be cleared. We probably can still clear the breakpoint, but
11989 since the other PC value is never presented to user, user
11990 can only find it by guessing, and it does not seem important
11991 to support that. */
11992
4a64f543
MS
11993 /* For each line spec given, delete bps which correspond to it. Do
11994 it in two passes, solely to preserve the current behavior that
11995 from_tty is forced true if we delete more than one
11996 breakpoint. */
c906108c 11997
80f8a6eb 11998 found = NULL;
8a2c437b 11999 make_cleanup (VEC_cleanup (breakpoint_p), &found);
c906108c
SS
12000 for (i = 0; i < sals.nelts; i++)
12001 {
05cba821
JK
12002 const char *sal_fullname;
12003
c906108c 12004 /* If exact pc given, clear bpts at that pc.
c5aa993b
JM
12005 If line given (pc == 0), clear all bpts on specified line.
12006 If defaulting, clear all bpts on default line
c906108c 12007 or at default pc.
c5aa993b
JM
12008
12009 defaulting sal.pc != 0 tests to do
12010
12011 0 1 pc
12012 1 1 pc _and_ line
12013 0 0 line
12014 1 0 <can't happen> */
c906108c
SS
12015
12016 sal = sals.sals[i];
05cba821
JK
12017 sal_fullname = (sal.symtab == NULL
12018 ? NULL : symtab_to_fullname (sal.symtab));
c906108c 12019
4a64f543 12020 /* Find all matching breakpoints and add them to 'found'. */
d6e956e5 12021 ALL_BREAKPOINTS (b)
c5aa993b 12022 {
0d381245 12023 int match = 0;
4a64f543 12024 /* Are we going to delete b? */
cc60f2e3 12025 if (b->type != bp_none && !is_watchpoint (b))
0d381245
VP
12026 {
12027 struct bp_location *loc = b->loc;
12028 for (; loc; loc = loc->next)
12029 {
f8eba3c6
TT
12030 /* If the user specified file:line, don't allow a PC
12031 match. This matches historical gdb behavior. */
12032 int pc_match = (!sal.explicit_line
12033 && sal.pc
12034 && (loc->pspace == sal.pspace)
12035 && (loc->address == sal.pc)
12036 && (!section_is_overlay (loc->section)
12037 || loc->section == sal.section));
4aac40c8
TT
12038 int line_match = 0;
12039
12040 if ((default_match || sal.explicit_line)
2f202fde 12041 && loc->symtab != NULL
05cba821 12042 && sal_fullname != NULL
4aac40c8 12043 && sal.pspace == loc->pspace
05cba821
JK
12044 && loc->line_number == sal.line
12045 && filename_cmp (symtab_to_fullname (loc->symtab),
12046 sal_fullname) == 0)
12047 line_match = 1;
4aac40c8 12048
0d381245
VP
12049 if (pc_match || line_match)
12050 {
12051 match = 1;
12052 break;
12053 }
12054 }
12055 }
12056
12057 if (match)
d6e956e5 12058 VEC_safe_push(breakpoint_p, found, b);
c906108c 12059 }
80f8a6eb 12060 }
8a2c437b 12061
80f8a6eb 12062 /* Now go thru the 'found' chain and delete them. */
d6e956e5 12063 if (VEC_empty(breakpoint_p, found))
80f8a6eb
MS
12064 {
12065 if (arg)
8a3fe4f8 12066 error (_("No breakpoint at %s."), arg);
80f8a6eb 12067 else
8a3fe4f8 12068 error (_("No breakpoint at this line."));
80f8a6eb 12069 }
c906108c 12070
8a2c437b
TT
12071 /* Remove duplicates from the vec. */
12072 qsort (VEC_address (breakpoint_p, found),
12073 VEC_length (breakpoint_p, found),
12074 sizeof (breakpoint_p),
12075 compare_breakpoints);
12076 prev = VEC_index (breakpoint_p, found, 0);
12077 for (ix = 1; VEC_iterate (breakpoint_p, found, ix, b); ++ix)
12078 {
12079 if (b == prev)
12080 {
12081 VEC_ordered_remove (breakpoint_p, found, ix);
12082 --ix;
12083 }
12084 }
12085
d6e956e5 12086 if (VEC_length(breakpoint_p, found) > 1)
4a64f543 12087 from_tty = 1; /* Always report if deleted more than one. */
80f8a6eb 12088 if (from_tty)
a3f17187 12089 {
d6e956e5 12090 if (VEC_length(breakpoint_p, found) == 1)
a3f17187
AC
12091 printf_unfiltered (_("Deleted breakpoint "));
12092 else
12093 printf_unfiltered (_("Deleted breakpoints "));
12094 }
d6e956e5
VP
12095
12096 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
80f8a6eb 12097 {
c5aa993b 12098 if (from_tty)
d6e956e5
VP
12099 printf_unfiltered ("%d ", b->number);
12100 delete_breakpoint (b);
c906108c 12101 }
80f8a6eb
MS
12102 if (from_tty)
12103 putchar_unfiltered ('\n');
8a2c437b
TT
12104
12105 do_cleanups (cleanups);
c906108c
SS
12106}
12107\f
12108/* Delete breakpoint in BS if they are `delete' breakpoints and
12109 all breakpoints that are marked for deletion, whether hit or not.
12110 This is called after any breakpoint is hit, or after errors. */
12111
12112void
fba45db2 12113breakpoint_auto_delete (bpstat bs)
c906108c 12114{
35df4500 12115 struct breakpoint *b, *b_tmp;
c906108c
SS
12116
12117 for (; bs; bs = bs->next)
f431efe5
PA
12118 if (bs->breakpoint_at
12119 && bs->breakpoint_at->disposition == disp_del
c906108c 12120 && bs->stop)
f431efe5 12121 delete_breakpoint (bs->breakpoint_at);
c906108c 12122
35df4500 12123 ALL_BREAKPOINTS_SAFE (b, b_tmp)
c5aa993b 12124 {
b5de0fa7 12125 if (b->disposition == disp_del_at_next_stop)
c5aa993b
JM
12126 delete_breakpoint (b);
12127 }
c906108c
SS
12128}
12129
4a64f543
MS
12130/* A comparison function for bp_location AP and BP being interfaced to
12131 qsort. Sort elements primarily by their ADDRESS (no matter what
12132 does breakpoint_address_is_meaningful say for its OWNER),
1a853c52 12133 secondarily by ordering first permanent elements and
4a64f543 12134 terciarily just ensuring the array is sorted stable way despite
e5dd4106 12135 qsort being an unstable algorithm. */
876fa593
JK
12136
12137static int
f5336ca5 12138bp_locations_compare (const void *ap, const void *bp)
876fa593 12139{
9a3c8263
SM
12140 const struct bp_location *a = *(const struct bp_location **) ap;
12141 const struct bp_location *b = *(const struct bp_location **) bp;
876fa593
JK
12142
12143 if (a->address != b->address)
12144 return (a->address > b->address) - (a->address < b->address);
12145
dea2aa5f
LM
12146 /* Sort locations at the same address by their pspace number, keeping
12147 locations of the same inferior (in a multi-inferior environment)
12148 grouped. */
12149
12150 if (a->pspace->num != b->pspace->num)
12151 return ((a->pspace->num > b->pspace->num)
12152 - (a->pspace->num < b->pspace->num));
12153
876fa593 12154 /* Sort permanent breakpoints first. */
1a853c52
PA
12155 if (a->permanent != b->permanent)
12156 return (a->permanent < b->permanent) - (a->permanent > b->permanent);
876fa593 12157
c56a97f9
JK
12158 /* Make the internal GDB representation stable across GDB runs
12159 where A and B memory inside GDB can differ. Breakpoint locations of
12160 the same type at the same address can be sorted in arbitrary order. */
876fa593
JK
12161
12162 if (a->owner->number != b->owner->number)
c56a97f9
JK
12163 return ((a->owner->number > b->owner->number)
12164 - (a->owner->number < b->owner->number));
876fa593
JK
12165
12166 return (a > b) - (a < b);
12167}
12168
f5336ca5
PA
12169/* Set bp_locations_placed_address_before_address_max and
12170 bp_locations_shadow_len_after_address_max according to the current
12171 content of the bp_locations array. */
f7545552
TT
12172
12173static void
f5336ca5 12174bp_locations_target_extensions_update (void)
f7545552 12175{
876fa593
JK
12176 struct bp_location *bl, **blp_tmp;
12177
f5336ca5
PA
12178 bp_locations_placed_address_before_address_max = 0;
12179 bp_locations_shadow_len_after_address_max = 0;
876fa593
JK
12180
12181 ALL_BP_LOCATIONS (bl, blp_tmp)
12182 {
12183 CORE_ADDR start, end, addr;
12184
12185 if (!bp_location_has_shadow (bl))
12186 continue;
12187
12188 start = bl->target_info.placed_address;
12189 end = start + bl->target_info.shadow_len;
12190
12191 gdb_assert (bl->address >= start);
12192 addr = bl->address - start;
f5336ca5
PA
12193 if (addr > bp_locations_placed_address_before_address_max)
12194 bp_locations_placed_address_before_address_max = addr;
876fa593
JK
12195
12196 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12197
12198 gdb_assert (bl->address < end);
12199 addr = end - bl->address;
f5336ca5
PA
12200 if (addr > bp_locations_shadow_len_after_address_max)
12201 bp_locations_shadow_len_after_address_max = addr;
876fa593 12202 }
f7545552
TT
12203}
12204
1e4d1764
YQ
12205/* Download tracepoint locations if they haven't been. */
12206
12207static void
12208download_tracepoint_locations (void)
12209{
7ed2c994 12210 struct breakpoint *b;
1e4d1764 12211 struct cleanup *old_chain;
dd2e65cc 12212 enum tribool can_download_tracepoint = TRIBOOL_UNKNOWN;
1e4d1764
YQ
12213
12214 old_chain = save_current_space_and_thread ();
12215
7ed2c994 12216 ALL_TRACEPOINTS (b)
1e4d1764 12217 {
7ed2c994 12218 struct bp_location *bl;
1e4d1764 12219 struct tracepoint *t;
f2a8bc8a 12220 int bp_location_downloaded = 0;
1e4d1764 12221
7ed2c994 12222 if ((b->type == bp_fast_tracepoint
1e4d1764
YQ
12223 ? !may_insert_fast_tracepoints
12224 : !may_insert_tracepoints))
12225 continue;
12226
dd2e65cc
YQ
12227 if (can_download_tracepoint == TRIBOOL_UNKNOWN)
12228 {
12229 if (target_can_download_tracepoint ())
12230 can_download_tracepoint = TRIBOOL_TRUE;
12231 else
12232 can_download_tracepoint = TRIBOOL_FALSE;
12233 }
12234
12235 if (can_download_tracepoint == TRIBOOL_FALSE)
12236 break;
12237
7ed2c994
YQ
12238 for (bl = b->loc; bl; bl = bl->next)
12239 {
12240 /* In tracepoint, locations are _never_ duplicated, so
12241 should_be_inserted is equivalent to
12242 unduplicated_should_be_inserted. */
12243 if (!should_be_inserted (bl) || bl->inserted)
12244 continue;
1e4d1764 12245
7ed2c994 12246 switch_to_program_space_and_thread (bl->pspace);
1e4d1764 12247
7ed2c994 12248 target_download_tracepoint (bl);
1e4d1764 12249
7ed2c994 12250 bl->inserted = 1;
f2a8bc8a 12251 bp_location_downloaded = 1;
7ed2c994
YQ
12252 }
12253 t = (struct tracepoint *) b;
12254 t->number_on_target = b->number;
f2a8bc8a
YQ
12255 if (bp_location_downloaded)
12256 observer_notify_breakpoint_modified (b);
1e4d1764
YQ
12257 }
12258
12259 do_cleanups (old_chain);
12260}
12261
934709f0
PW
12262/* Swap the insertion/duplication state between two locations. */
12263
12264static void
12265swap_insertion (struct bp_location *left, struct bp_location *right)
12266{
12267 const int left_inserted = left->inserted;
12268 const int left_duplicate = left->duplicate;
b775012e 12269 const int left_needs_update = left->needs_update;
934709f0
PW
12270 const struct bp_target_info left_target_info = left->target_info;
12271
1e4d1764
YQ
12272 /* Locations of tracepoints can never be duplicated. */
12273 if (is_tracepoint (left->owner))
12274 gdb_assert (!left->duplicate);
12275 if (is_tracepoint (right->owner))
12276 gdb_assert (!right->duplicate);
12277
934709f0
PW
12278 left->inserted = right->inserted;
12279 left->duplicate = right->duplicate;
b775012e 12280 left->needs_update = right->needs_update;
934709f0
PW
12281 left->target_info = right->target_info;
12282 right->inserted = left_inserted;
12283 right->duplicate = left_duplicate;
b775012e 12284 right->needs_update = left_needs_update;
934709f0
PW
12285 right->target_info = left_target_info;
12286}
12287
b775012e
LM
12288/* Force the re-insertion of the locations at ADDRESS. This is called
12289 once a new/deleted/modified duplicate location is found and we are evaluating
12290 conditions on the target's side. Such conditions need to be updated on
12291 the target. */
12292
12293static void
12294force_breakpoint_reinsertion (struct bp_location *bl)
12295{
12296 struct bp_location **locp = NULL, **loc2p;
12297 struct bp_location *loc;
12298 CORE_ADDR address = 0;
12299 int pspace_num;
12300
12301 address = bl->address;
12302 pspace_num = bl->pspace->num;
12303
12304 /* This is only meaningful if the target is
12305 evaluating conditions and if the user has
12306 opted for condition evaluation on the target's
12307 side. */
12308 if (gdb_evaluates_breakpoint_condition_p ()
12309 || !target_supports_evaluation_of_breakpoint_conditions ())
12310 return;
12311
12312 /* Flag all breakpoint locations with this address and
12313 the same program space as the location
12314 as "its condition has changed". We need to
12315 update the conditions on the target's side. */
12316 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
12317 {
12318 loc = *loc2p;
12319
12320 if (!is_breakpoint (loc->owner)
12321 || pspace_num != loc->pspace->num)
12322 continue;
12323
12324 /* Flag the location appropriately. We use a different state to
12325 let everyone know that we already updated the set of locations
12326 with addr bl->address and program space bl->pspace. This is so
12327 we don't have to keep calling these functions just to mark locations
12328 that have already been marked. */
12329 loc->condition_changed = condition_updated;
12330
12331 /* Free the agent expression bytecode as well. We will compute
12332 it later on. */
833177a4 12333 loc->cond_bytecode.reset ();
b775012e
LM
12334 }
12335}
44702360
PA
12336/* Called whether new breakpoints are created, or existing breakpoints
12337 deleted, to update the global location list and recompute which
12338 locations are duplicate of which.
b775012e 12339
04086b45
PA
12340 The INSERT_MODE flag determines whether locations may not, may, or
12341 shall be inserted now. See 'enum ugll_insert_mode' for more
12342 info. */
b60e7edf 12343
0d381245 12344static void
44702360 12345update_global_location_list (enum ugll_insert_mode insert_mode)
0d381245 12346{
74960c60 12347 struct breakpoint *b;
876fa593 12348 struct bp_location **locp, *loc;
f7545552 12349 struct cleanup *cleanups;
b775012e
LM
12350 /* Last breakpoint location address that was marked for update. */
12351 CORE_ADDR last_addr = 0;
12352 /* Last breakpoint location program space that was marked for update. */
12353 int last_pspace_num = -1;
f7545552 12354
2d134ed3
PA
12355 /* Used in the duplicates detection below. When iterating over all
12356 bp_locations, points to the first bp_location of a given address.
12357 Breakpoints and watchpoints of different types are never
12358 duplicates of each other. Keep one pointer for each type of
12359 breakpoint/watchpoint, so we only need to loop over all locations
12360 once. */
12361 struct bp_location *bp_loc_first; /* breakpoint */
12362 struct bp_location *wp_loc_first; /* hardware watchpoint */
12363 struct bp_location *awp_loc_first; /* access watchpoint */
12364 struct bp_location *rwp_loc_first; /* read watchpoint */
876fa593 12365
f5336ca5
PA
12366 /* Saved former bp_locations array which we compare against the newly
12367 built bp_locations from the current state of ALL_BREAKPOINTS. */
12368 struct bp_location **old_locations, **old_locp;
12369 unsigned old_locations_count;
876fa593 12370
f5336ca5
PA
12371 old_locations = bp_locations;
12372 old_locations_count = bp_locations_count;
12373 bp_locations = NULL;
12374 bp_locations_count = 0;
12375 cleanups = make_cleanup (xfree, old_locations);
0d381245 12376
74960c60 12377 ALL_BREAKPOINTS (b)
876fa593 12378 for (loc = b->loc; loc; loc = loc->next)
f5336ca5 12379 bp_locations_count++;
876fa593 12380
f5336ca5
PA
12381 bp_locations = XNEWVEC (struct bp_location *, bp_locations_count);
12382 locp = bp_locations;
876fa593
JK
12383 ALL_BREAKPOINTS (b)
12384 for (loc = b->loc; loc; loc = loc->next)
12385 *locp++ = loc;
f5336ca5
PA
12386 qsort (bp_locations, bp_locations_count, sizeof (*bp_locations),
12387 bp_locations_compare);
876fa593 12388
f5336ca5 12389 bp_locations_target_extensions_update ();
74960c60 12390
4a64f543
MS
12391 /* Identify bp_location instances that are no longer present in the
12392 new list, and therefore should be freed. Note that it's not
12393 necessary that those locations should be removed from inferior --
12394 if there's another location at the same address (previously
12395 marked as duplicate), we don't need to remove/insert the
12396 location.
876fa593 12397
4a64f543
MS
12398 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12399 and former bp_location array state respectively. */
876fa593 12400
f5336ca5
PA
12401 locp = bp_locations;
12402 for (old_locp = old_locations;
12403 old_locp < old_locations + old_locations_count;
876fa593 12404 old_locp++)
74960c60 12405 {
876fa593 12406 struct bp_location *old_loc = *old_locp;
c7d46a38 12407 struct bp_location **loc2p;
876fa593 12408
e5dd4106 12409 /* Tells if 'old_loc' is found among the new locations. If
4a64f543 12410 not, we have to free it. */
c7d46a38 12411 int found_object = 0;
20874c92
VP
12412 /* Tells if the location should remain inserted in the target. */
12413 int keep_in_target = 0;
12414 int removed = 0;
876fa593 12415
4a64f543
MS
12416 /* Skip LOCP entries which will definitely never be needed.
12417 Stop either at or being the one matching OLD_LOC. */
f5336ca5 12418 while (locp < bp_locations + bp_locations_count
c7d46a38 12419 && (*locp)->address < old_loc->address)
876fa593 12420 locp++;
c7d46a38
PA
12421
12422 for (loc2p = locp;
f5336ca5 12423 (loc2p < bp_locations + bp_locations_count
c7d46a38
PA
12424 && (*loc2p)->address == old_loc->address);
12425 loc2p++)
12426 {
b775012e
LM
12427 /* Check if this is a new/duplicated location or a duplicated
12428 location that had its condition modified. If so, we want to send
12429 its condition to the target if evaluation of conditions is taking
12430 place there. */
12431 if ((*loc2p)->condition_changed == condition_modified
12432 && (last_addr != old_loc->address
12433 || last_pspace_num != old_loc->pspace->num))
c7d46a38 12434 {
b775012e
LM
12435 force_breakpoint_reinsertion (*loc2p);
12436 last_pspace_num = old_loc->pspace->num;
c7d46a38 12437 }
b775012e
LM
12438
12439 if (*loc2p == old_loc)
12440 found_object = 1;
c7d46a38 12441 }
74960c60 12442
b775012e
LM
12443 /* We have already handled this address, update it so that we don't
12444 have to go through updates again. */
12445 last_addr = old_loc->address;
12446
12447 /* Target-side condition evaluation: Handle deleted locations. */
12448 if (!found_object)
12449 force_breakpoint_reinsertion (old_loc);
12450
4a64f543
MS
12451 /* If this location is no longer present, and inserted, look if
12452 there's maybe a new location at the same address. If so,
12453 mark that one inserted, and don't remove this one. This is
12454 needed so that we don't have a time window where a breakpoint
12455 at certain location is not inserted. */
74960c60 12456
876fa593 12457 if (old_loc->inserted)
0d381245 12458 {
4a64f543
MS
12459 /* If the location is inserted now, we might have to remove
12460 it. */
74960c60 12461
876fa593 12462 if (found_object && should_be_inserted (old_loc))
74960c60 12463 {
4a64f543
MS
12464 /* The location is still present in the location list,
12465 and still should be inserted. Don't do anything. */
20874c92 12466 keep_in_target = 1;
74960c60
VP
12467 }
12468 else
12469 {
b775012e
LM
12470 /* This location still exists, but it won't be kept in the
12471 target since it may have been disabled. We proceed to
12472 remove its target-side condition. */
12473
4a64f543
MS
12474 /* The location is either no longer present, or got
12475 disabled. See if there's another location at the
12476 same address, in which case we don't need to remove
12477 this one from the target. */
876fa593 12478
2bdf28a0 12479 /* OLD_LOC comes from existing struct breakpoint. */
876fa593
JK
12480 if (breakpoint_address_is_meaningful (old_loc->owner))
12481 {
876fa593 12482 for (loc2p = locp;
f5336ca5 12483 (loc2p < bp_locations + bp_locations_count
c7d46a38 12484 && (*loc2p)->address == old_loc->address);
876fa593
JK
12485 loc2p++)
12486 {
12487 struct bp_location *loc2 = *loc2p;
12488
2d134ed3 12489 if (breakpoint_locations_match (loc2, old_loc))
c7d46a38 12490 {
85d721b8
PA
12491 /* Read watchpoint locations are switched to
12492 access watchpoints, if the former are not
12493 supported, but the latter are. */
12494 if (is_hardware_watchpoint (old_loc->owner))
12495 {
12496 gdb_assert (is_hardware_watchpoint (loc2->owner));
12497 loc2->watchpoint_type = old_loc->watchpoint_type;
12498 }
12499
934709f0
PW
12500 /* loc2 is a duplicated location. We need to check
12501 if it should be inserted in case it will be
12502 unduplicated. */
12503 if (loc2 != old_loc
12504 && unduplicated_should_be_inserted (loc2))
c7d46a38 12505 {
934709f0 12506 swap_insertion (old_loc, loc2);
c7d46a38
PA
12507 keep_in_target = 1;
12508 break;
12509 }
876fa593
JK
12510 }
12511 }
12512 }
74960c60
VP
12513 }
12514
20874c92
VP
12515 if (!keep_in_target)
12516 {
834c0d03 12517 if (remove_breakpoint (old_loc))
20874c92 12518 {
4a64f543
MS
12519 /* This is just about all we can do. We could keep
12520 this location on the global list, and try to
12521 remove it next time, but there's no particular
12522 reason why we will succeed next time.
20874c92 12523
4a64f543
MS
12524 Note that at this point, old_loc->owner is still
12525 valid, as delete_breakpoint frees the breakpoint
12526 only after calling us. */
3e43a32a
MS
12527 printf_filtered (_("warning: Error removing "
12528 "breakpoint %d\n"),
876fa593 12529 old_loc->owner->number);
20874c92
VP
12530 }
12531 removed = 1;
12532 }
0d381245 12533 }
74960c60
VP
12534
12535 if (!found_object)
1c5cfe86 12536 {
fbea99ea 12537 if (removed && target_is_non_stop_p ()
1cf4d951 12538 && need_moribund_for_location_type (old_loc))
20874c92 12539 {
db82e815
PA
12540 /* This location was removed from the target. In
12541 non-stop mode, a race condition is possible where
12542 we've removed a breakpoint, but stop events for that
12543 breakpoint are already queued and will arrive later.
12544 We apply an heuristic to be able to distinguish such
12545 SIGTRAPs from other random SIGTRAPs: we keep this
12546 breakpoint location for a bit, and will retire it
12547 after we see some number of events. The theory here
12548 is that reporting of events should, "on the average",
12549 be fair, so after a while we'll see events from all
12550 threads that have anything of interest, and no longer
12551 need to keep this breakpoint location around. We
12552 don't hold locations forever so to reduce chances of
12553 mistaking a non-breakpoint SIGTRAP for a breakpoint
12554 SIGTRAP.
12555
12556 The heuristic failing can be disastrous on
12557 decr_pc_after_break targets.
12558
12559 On decr_pc_after_break targets, like e.g., x86-linux,
12560 if we fail to recognize a late breakpoint SIGTRAP,
12561 because events_till_retirement has reached 0 too
12562 soon, we'll fail to do the PC adjustment, and report
12563 a random SIGTRAP to the user. When the user resumes
12564 the inferior, it will most likely immediately crash
2dec564e 12565 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
db82e815
PA
12566 corrupted, because of being resumed e.g., in the
12567 middle of a multi-byte instruction, or skipped a
12568 one-byte instruction. This was actually seen happen
12569 on native x86-linux, and should be less rare on
12570 targets that do not support new thread events, like
12571 remote, due to the heuristic depending on
12572 thread_count.
12573
12574 Mistaking a random SIGTRAP for a breakpoint trap
12575 causes similar symptoms (PC adjustment applied when
12576 it shouldn't), but then again, playing with SIGTRAPs
12577 behind the debugger's back is asking for trouble.
12578
12579 Since hardware watchpoint traps are always
12580 distinguishable from other traps, so we don't need to
12581 apply keep hardware watchpoint moribund locations
12582 around. We simply always ignore hardware watchpoint
12583 traps we can no longer explain. */
12584
876fa593
JK
12585 old_loc->events_till_retirement = 3 * (thread_count () + 1);
12586 old_loc->owner = NULL;
20874c92 12587
876fa593 12588 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
1c5cfe86
PA
12589 }
12590 else
f431efe5
PA
12591 {
12592 old_loc->owner = NULL;
12593 decref_bp_location (&old_loc);
12594 }
20874c92 12595 }
74960c60 12596 }
1c5cfe86 12597
348d480f
PA
12598 /* Rescan breakpoints at the same address and section, marking the
12599 first one as "first" and any others as "duplicates". This is so
12600 that the bpt instruction is only inserted once. If we have a
12601 permanent breakpoint at the same place as BPT, make that one the
12602 official one, and the rest as duplicates. Permanent breakpoints
12603 are sorted first for the same address.
12604
12605 Do the same for hardware watchpoints, but also considering the
12606 watchpoint's type (regular/access/read) and length. */
12607
12608 bp_loc_first = NULL;
12609 wp_loc_first = NULL;
12610 awp_loc_first = NULL;
12611 rwp_loc_first = NULL;
12612 ALL_BP_LOCATIONS (loc, locp)
12613 {
12614 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12615 non-NULL. */
348d480f 12616 struct bp_location **loc_first_p;
d3fbdd86 12617 b = loc->owner;
348d480f 12618
6f380991 12619 if (!unduplicated_should_be_inserted (loc)
348d480f 12620 || !breakpoint_address_is_meaningful (b)
1e4d1764
YQ
12621 /* Don't detect duplicate for tracepoint locations because they are
12622 never duplicated. See the comments in field `duplicate' of
12623 `struct bp_location'. */
348d480f 12624 || is_tracepoint (b))
b775012e
LM
12625 {
12626 /* Clear the condition modification flag. */
12627 loc->condition_changed = condition_unchanged;
12628 continue;
12629 }
348d480f 12630
348d480f
PA
12631 if (b->type == bp_hardware_watchpoint)
12632 loc_first_p = &wp_loc_first;
12633 else if (b->type == bp_read_watchpoint)
12634 loc_first_p = &rwp_loc_first;
12635 else if (b->type == bp_access_watchpoint)
12636 loc_first_p = &awp_loc_first;
12637 else
12638 loc_first_p = &bp_loc_first;
12639
12640 if (*loc_first_p == NULL
12641 || (overlay_debugging && loc->section != (*loc_first_p)->section)
12642 || !breakpoint_locations_match (loc, *loc_first_p))
12643 {
12644 *loc_first_p = loc;
12645 loc->duplicate = 0;
b775012e
LM
12646
12647 if (is_breakpoint (loc->owner) && loc->condition_changed)
12648 {
12649 loc->needs_update = 1;
12650 /* Clear the condition modification flag. */
12651 loc->condition_changed = condition_unchanged;
12652 }
348d480f
PA
12653 continue;
12654 }
12655
934709f0
PW
12656
12657 /* This and the above ensure the invariant that the first location
12658 is not duplicated, and is the inserted one.
12659 All following are marked as duplicated, and are not inserted. */
12660 if (loc->inserted)
12661 swap_insertion (loc, *loc_first_p);
348d480f
PA
12662 loc->duplicate = 1;
12663
b775012e
LM
12664 /* Clear the condition modification flag. */
12665 loc->condition_changed = condition_unchanged;
348d480f
PA
12666 }
12667
a25a5a45 12668 if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
b775012e 12669 {
04086b45 12670 if (insert_mode != UGLL_DONT_INSERT)
b775012e
LM
12671 insert_breakpoint_locations ();
12672 else
12673 {
44702360
PA
12674 /* Even though the caller told us to not insert new
12675 locations, we may still need to update conditions on the
12676 target's side of breakpoints that were already inserted
12677 if the target is evaluating breakpoint conditions. We
b775012e
LM
12678 only update conditions for locations that are marked
12679 "needs_update". */
12680 update_inserted_breakpoint_locations ();
12681 }
12682 }
348d480f 12683
04086b45 12684 if (insert_mode != UGLL_DONT_INSERT)
1e4d1764
YQ
12685 download_tracepoint_locations ();
12686
348d480f
PA
12687 do_cleanups (cleanups);
12688}
12689
12690void
12691breakpoint_retire_moribund (void)
12692{
12693 struct bp_location *loc;
12694 int ix;
12695
12696 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12697 if (--(loc->events_till_retirement) == 0)
12698 {
12699 decref_bp_location (&loc);
12700 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12701 --ix;
12702 }
12703}
12704
12705static void
44702360 12706update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
348d480f 12707{
348d480f 12708
492d29ea
PA
12709 TRY
12710 {
12711 update_global_location_list (insert_mode);
12712 }
12713 CATCH (e, RETURN_MASK_ERROR)
12714 {
12715 }
12716 END_CATCH
348d480f
PA
12717}
12718
12719/* Clear BKP from a BPS. */
12720
12721static void
12722bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12723{
12724 bpstat bs;
12725
12726 for (bs = bps; bs; bs = bs->next)
12727 if (bs->breakpoint_at == bpt)
12728 {
12729 bs->breakpoint_at = NULL;
12730 bs->old_val = NULL;
12731 /* bs->commands will be freed later. */
12732 }
12733}
12734
12735/* Callback for iterate_over_threads. */
12736static int
12737bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12738{
9a3c8263 12739 struct breakpoint *bpt = (struct breakpoint *) data;
348d480f
PA
12740
12741 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12742 return 0;
12743}
12744
12745/* Helper for breakpoint and tracepoint breakpoint_ops->mention
12746 callbacks. */
12747
12748static void
12749say_where (struct breakpoint *b)
12750{
12751 struct value_print_options opts;
12752
12753 get_user_print_options (&opts);
12754
12755 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12756 single string. */
12757 if (b->loc == NULL)
12758 {
f00aae0f
KS
12759 /* For pending locations, the output differs slightly based
12760 on b->extra_string. If this is non-NULL, it contains either
12761 a condition or dprintf arguments. */
12762 if (b->extra_string == NULL)
12763 {
12764 printf_filtered (_(" (%s) pending."),
d28cd78a 12765 event_location_to_string (b->location.get ()));
f00aae0f
KS
12766 }
12767 else if (b->type == bp_dprintf)
12768 {
12769 printf_filtered (_(" (%s,%s) pending."),
d28cd78a 12770 event_location_to_string (b->location.get ()),
f00aae0f
KS
12771 b->extra_string);
12772 }
12773 else
12774 {
12775 printf_filtered (_(" (%s %s) pending."),
d28cd78a 12776 event_location_to_string (b->location.get ()),
f00aae0f
KS
12777 b->extra_string);
12778 }
348d480f
PA
12779 }
12780 else
12781 {
2f202fde 12782 if (opts.addressprint || b->loc->symtab == NULL)
348d480f
PA
12783 {
12784 printf_filtered (" at ");
12785 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12786 gdb_stdout);
12787 }
2f202fde 12788 if (b->loc->symtab != NULL)
f8eba3c6
TT
12789 {
12790 /* If there is a single location, we can print the location
12791 more nicely. */
12792 if (b->loc->next == NULL)
12793 printf_filtered (": file %s, line %d.",
05cba821
JK
12794 symtab_to_filename_for_display (b->loc->symtab),
12795 b->loc->line_number);
f8eba3c6
TT
12796 else
12797 /* This is not ideal, but each location may have a
12798 different file name, and this at least reflects the
12799 real situation somewhat. */
f00aae0f 12800 printf_filtered (": %s.",
d28cd78a 12801 event_location_to_string (b->location.get ()));
f8eba3c6 12802 }
348d480f
PA
12803
12804 if (b->loc->next)
12805 {
12806 struct bp_location *loc = b->loc;
12807 int n = 0;
12808 for (; loc; loc = loc->next)
12809 ++n;
12810 printf_filtered (" (%d locations)", n);
12811 }
12812 }
12813}
12814
348d480f
PA
12815/* Default bp_location_ops methods. */
12816
12817static void
12818bp_location_dtor (struct bp_location *self)
12819{
348d480f
PA
12820 xfree (self->function_name);
12821}
12822
12823static const struct bp_location_ops bp_location_ops =
12824{
12825 bp_location_dtor
12826};
12827
2060206e
PA
12828/* Default breakpoint_ops methods all breakpoint_ops ultimately
12829 inherit from. */
348d480f 12830
2060206e
PA
12831static void
12832base_breakpoint_dtor (struct breakpoint *self)
348d480f
PA
12833{
12834 decref_counted_command_line (&self->commands);
12835 xfree (self->cond_string);
fb81d016 12836 xfree (self->extra_string);
f8eba3c6 12837 xfree (self->filter);
348d480f
PA
12838}
12839
2060206e
PA
12840static struct bp_location *
12841base_breakpoint_allocate_location (struct breakpoint *self)
348d480f
PA
12842{
12843 struct bp_location *loc;
12844
4d01a485 12845 loc = new struct bp_location ();
348d480f
PA
12846 init_bp_location (loc, &bp_location_ops, self);
12847 return loc;
12848}
12849
2060206e
PA
12850static void
12851base_breakpoint_re_set (struct breakpoint *b)
12852{
12853 /* Nothing to re-set. */
12854}
12855
12856#define internal_error_pure_virtual_called() \
12857 gdb_assert_not_reached ("pure virtual function called")
12858
12859static int
12860base_breakpoint_insert_location (struct bp_location *bl)
12861{
12862 internal_error_pure_virtual_called ();
12863}
12864
12865static int
73971819
PA
12866base_breakpoint_remove_location (struct bp_location *bl,
12867 enum remove_bp_reason reason)
2060206e
PA
12868{
12869 internal_error_pure_virtual_called ();
12870}
12871
12872static int
12873base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12874 struct address_space *aspace,
09ac7c10
TT
12875 CORE_ADDR bp_addr,
12876 const struct target_waitstatus *ws)
2060206e
PA
12877{
12878 internal_error_pure_virtual_called ();
12879}
12880
12881static void
12882base_breakpoint_check_status (bpstat bs)
12883{
12884 /* Always stop. */
12885}
12886
12887/* A "works_in_software_mode" breakpoint_ops method that just internal
12888 errors. */
12889
12890static int
12891base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12892{
12893 internal_error_pure_virtual_called ();
12894}
12895
12896/* A "resources_needed" breakpoint_ops method that just internal
12897 errors. */
12898
12899static int
12900base_breakpoint_resources_needed (const struct bp_location *bl)
12901{
12902 internal_error_pure_virtual_called ();
12903}
12904
12905static enum print_stop_action
12906base_breakpoint_print_it (bpstat bs)
12907{
12908 internal_error_pure_virtual_called ();
12909}
12910
12911static void
12912base_breakpoint_print_one_detail (const struct breakpoint *self,
12913 struct ui_out *uiout)
12914{
12915 /* nothing */
12916}
12917
12918static void
12919base_breakpoint_print_mention (struct breakpoint *b)
12920{
12921 internal_error_pure_virtual_called ();
12922}
12923
12924static void
12925base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12926{
12927 internal_error_pure_virtual_called ();
12928}
12929
983af33b 12930static void
f00aae0f
KS
12931base_breakpoint_create_sals_from_location
12932 (const struct event_location *location,
12933 struct linespec_result *canonical,
12934 enum bptype type_wanted)
983af33b
SDJ
12935{
12936 internal_error_pure_virtual_called ();
12937}
12938
12939static void
12940base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12941 struct linespec_result *c,
983af33b 12942 char *cond_string,
e7e0cddf 12943 char *extra_string,
983af33b
SDJ
12944 enum bptype type_wanted,
12945 enum bpdisp disposition,
12946 int thread,
12947 int task, int ignore_count,
12948 const struct breakpoint_ops *o,
12949 int from_tty, int enabled,
44f238bb 12950 int internal, unsigned flags)
983af33b
SDJ
12951{
12952 internal_error_pure_virtual_called ();
12953}
12954
12955static void
f00aae0f
KS
12956base_breakpoint_decode_location (struct breakpoint *b,
12957 const struct event_location *location,
c2f4122d 12958 struct program_space *search_pspace,
983af33b
SDJ
12959 struct symtabs_and_lines *sals)
12960{
12961 internal_error_pure_virtual_called ();
12962}
12963
ab04a2af
TT
12964/* The default 'explains_signal' method. */
12965
47591c29 12966static int
427cd150 12967base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
ab04a2af 12968{
47591c29 12969 return 1;
ab04a2af
TT
12970}
12971
9d6e6e84
HZ
12972/* The default "after_condition_true" method. */
12973
12974static void
12975base_breakpoint_after_condition_true (struct bpstats *bs)
12976{
12977 /* Nothing to do. */
12978}
12979
ab04a2af 12980struct breakpoint_ops base_breakpoint_ops =
2060206e
PA
12981{
12982 base_breakpoint_dtor,
12983 base_breakpoint_allocate_location,
12984 base_breakpoint_re_set,
12985 base_breakpoint_insert_location,
12986 base_breakpoint_remove_location,
12987 base_breakpoint_breakpoint_hit,
12988 base_breakpoint_check_status,
12989 base_breakpoint_resources_needed,
12990 base_breakpoint_works_in_software_mode,
12991 base_breakpoint_print_it,
12992 NULL,
12993 base_breakpoint_print_one_detail,
12994 base_breakpoint_print_mention,
983af33b 12995 base_breakpoint_print_recreate,
5f700d83 12996 base_breakpoint_create_sals_from_location,
983af33b 12997 base_breakpoint_create_breakpoints_sal,
5f700d83 12998 base_breakpoint_decode_location,
9d6e6e84
HZ
12999 base_breakpoint_explains_signal,
13000 base_breakpoint_after_condition_true,
2060206e
PA
13001};
13002
13003/* Default breakpoint_ops methods. */
13004
13005static void
348d480f
PA
13006bkpt_re_set (struct breakpoint *b)
13007{
06edf0c0 13008 /* FIXME: is this still reachable? */
9ef9e6a6 13009 if (breakpoint_event_location_empty_p (b))
06edf0c0 13010 {
f00aae0f 13011 /* Anything without a location can't be re-set. */
348d480f 13012 delete_breakpoint (b);
06edf0c0 13013 return;
348d480f 13014 }
06edf0c0
PA
13015
13016 breakpoint_re_set_default (b);
348d480f
PA
13017}
13018
2060206e 13019static int
348d480f
PA
13020bkpt_insert_location (struct bp_location *bl)
13021{
cd6c3b4f
YQ
13022 CORE_ADDR addr = bl->target_info.reqstd_address;
13023
579c6ad9 13024 bl->target_info.kind = breakpoint_kind (bl, &addr);
cd6c3b4f
YQ
13025 bl->target_info.placed_address = addr;
13026
348d480f 13027 if (bl->loc_type == bp_loc_hardware_breakpoint)
7c16b83e 13028 return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
348d480f 13029 else
7c16b83e 13030 return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
348d480f
PA
13031}
13032
2060206e 13033static int
73971819 13034bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason)
348d480f
PA
13035{
13036 if (bl->loc_type == bp_loc_hardware_breakpoint)
13037 return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
13038 else
73971819 13039 return target_remove_breakpoint (bl->gdbarch, &bl->target_info, reason);
348d480f
PA
13040}
13041
2060206e 13042static int
348d480f 13043bkpt_breakpoint_hit (const struct bp_location *bl,
09ac7c10
TT
13044 struct address_space *aspace, CORE_ADDR bp_addr,
13045 const struct target_waitstatus *ws)
348d480f 13046{
09ac7c10 13047 if (ws->kind != TARGET_WAITKIND_STOPPED
a493e3e2 13048 || ws->value.sig != GDB_SIGNAL_TRAP)
09ac7c10
TT
13049 return 0;
13050
348d480f
PA
13051 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
13052 aspace, bp_addr))
13053 return 0;
13054
13055 if (overlay_debugging /* unmapped overlay section */
13056 && section_is_overlay (bl->section)
13057 && !section_is_mapped (bl->section))
13058 return 0;
13059
13060 return 1;
13061}
13062
cd1608cc
PA
13063static int
13064dprintf_breakpoint_hit (const struct bp_location *bl,
13065 struct address_space *aspace, CORE_ADDR bp_addr,
13066 const struct target_waitstatus *ws)
13067{
13068 if (dprintf_style == dprintf_style_agent
13069 && target_can_run_breakpoint_commands ())
13070 {
13071 /* An agent-style dprintf never causes a stop. If we see a trap
13072 for this address it must be for a breakpoint that happens to
13073 be set at the same address. */
13074 return 0;
13075 }
13076
13077 return bkpt_breakpoint_hit (bl, aspace, bp_addr, ws);
13078}
13079
2060206e 13080static int
348d480f
PA
13081bkpt_resources_needed (const struct bp_location *bl)
13082{
13083 gdb_assert (bl->owner->type == bp_hardware_breakpoint);
13084
13085 return 1;
13086}
13087
2060206e 13088static enum print_stop_action
348d480f
PA
13089bkpt_print_it (bpstat bs)
13090{
348d480f
PA
13091 struct breakpoint *b;
13092 const struct bp_location *bl;
001c8c33 13093 int bp_temp;
79a45e25 13094 struct ui_out *uiout = current_uiout;
348d480f
PA
13095
13096 gdb_assert (bs->bp_location_at != NULL);
13097
13098 bl = bs->bp_location_at;
13099 b = bs->breakpoint_at;
13100
001c8c33
PA
13101 bp_temp = b->disposition == disp_del;
13102 if (bl->address != bl->requested_address)
13103 breakpoint_adjustment_warning (bl->requested_address,
13104 bl->address,
13105 b->number, 1);
13106 annotate_breakpoint (b->number);
f303dbd6
PA
13107 maybe_print_thread_hit_breakpoint (uiout);
13108
001c8c33 13109 if (bp_temp)
112e8700 13110 uiout->text ("Temporary breakpoint ");
001c8c33 13111 else
112e8700
SM
13112 uiout->text ("Breakpoint ");
13113 if (uiout->is_mi_like_p ())
348d480f 13114 {
112e8700 13115 uiout->field_string ("reason",
001c8c33 13116 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
112e8700 13117 uiout->field_string ("disp", bpdisp_text (b->disposition));
06edf0c0 13118 }
112e8700
SM
13119 uiout->field_int ("bkptno", b->number);
13120 uiout->text (", ");
06edf0c0 13121
001c8c33 13122 return PRINT_SRC_AND_LOC;
06edf0c0
PA
13123}
13124
2060206e 13125static void
06edf0c0
PA
13126bkpt_print_mention (struct breakpoint *b)
13127{
112e8700 13128 if (current_uiout->is_mi_like_p ())
06edf0c0
PA
13129 return;
13130
13131 switch (b->type)
13132 {
13133 case bp_breakpoint:
13134 case bp_gnu_ifunc_resolver:
13135 if (b->disposition == disp_del)
13136 printf_filtered (_("Temporary breakpoint"));
13137 else
13138 printf_filtered (_("Breakpoint"));
13139 printf_filtered (_(" %d"), b->number);
13140 if (b->type == bp_gnu_ifunc_resolver)
13141 printf_filtered (_(" at gnu-indirect-function resolver"));
13142 break;
13143 case bp_hardware_breakpoint:
13144 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
13145 break;
e7e0cddf
SS
13146 case bp_dprintf:
13147 printf_filtered (_("Dprintf %d"), b->number);
13148 break;
06edf0c0
PA
13149 }
13150
13151 say_where (b);
13152}
13153
2060206e 13154static void
06edf0c0
PA
13155bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13156{
13157 if (tp->type == bp_breakpoint && tp->disposition == disp_del)
13158 fprintf_unfiltered (fp, "tbreak");
13159 else if (tp->type == bp_breakpoint)
13160 fprintf_unfiltered (fp, "break");
13161 else if (tp->type == bp_hardware_breakpoint
13162 && tp->disposition == disp_del)
13163 fprintf_unfiltered (fp, "thbreak");
13164 else if (tp->type == bp_hardware_breakpoint)
13165 fprintf_unfiltered (fp, "hbreak");
13166 else
13167 internal_error (__FILE__, __LINE__,
13168 _("unhandled breakpoint type %d"), (int) tp->type);
13169
f00aae0f 13170 fprintf_unfiltered (fp, " %s",
d28cd78a 13171 event_location_to_string (tp->location.get ()));
f00aae0f
KS
13172
13173 /* Print out extra_string if this breakpoint is pending. It might
13174 contain, for example, conditions that were set by the user. */
13175 if (tp->loc == NULL && tp->extra_string != NULL)
13176 fprintf_unfiltered (fp, " %s", tp->extra_string);
13177
dd11a36c 13178 print_recreate_thread (tp, fp);
06edf0c0
PA
13179}
13180
983af33b 13181static void
f00aae0f
KS
13182bkpt_create_sals_from_location (const struct event_location *location,
13183 struct linespec_result *canonical,
13184 enum bptype type_wanted)
983af33b 13185{
f00aae0f 13186 create_sals_from_location_default (location, canonical, type_wanted);
983af33b
SDJ
13187}
13188
13189static void
13190bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
13191 struct linespec_result *canonical,
983af33b 13192 char *cond_string,
e7e0cddf 13193 char *extra_string,
983af33b
SDJ
13194 enum bptype type_wanted,
13195 enum bpdisp disposition,
13196 int thread,
13197 int task, int ignore_count,
13198 const struct breakpoint_ops *ops,
13199 int from_tty, int enabled,
44f238bb 13200 int internal, unsigned flags)
983af33b 13201{
023fa29b 13202 create_breakpoints_sal_default (gdbarch, canonical,
e7e0cddf
SS
13203 cond_string, extra_string,
13204 type_wanted,
983af33b
SDJ
13205 disposition, thread, task,
13206 ignore_count, ops, from_tty,
44f238bb 13207 enabled, internal, flags);
983af33b
SDJ
13208}
13209
13210static void
f00aae0f
KS
13211bkpt_decode_location (struct breakpoint *b,
13212 const struct event_location *location,
c2f4122d 13213 struct program_space *search_pspace,
983af33b
SDJ
13214 struct symtabs_and_lines *sals)
13215{
c2f4122d 13216 decode_location_default (b, location, search_pspace, sals);
983af33b
SDJ
13217}
13218
06edf0c0
PA
13219/* Virtual table for internal breakpoints. */
13220
13221static void
13222internal_bkpt_re_set (struct breakpoint *b)
13223{
13224 switch (b->type)
13225 {
13226 /* Delete overlay event and longjmp master breakpoints; they
13227 will be reset later by breakpoint_re_set. */
13228 case bp_overlay_event:
13229 case bp_longjmp_master:
13230 case bp_std_terminate_master:
13231 case bp_exception_master:
13232 delete_breakpoint (b);
13233 break;
13234
13235 /* This breakpoint is special, it's set up when the inferior
13236 starts and we really don't want to touch it. */
13237 case bp_shlib_event:
13238
13239 /* Like bp_shlib_event, this breakpoint type is special. Once
13240 it is set up, we do not want to touch it. */
13241 case bp_thread_event:
13242 break;
13243 }
13244}
13245
13246static void
13247internal_bkpt_check_status (bpstat bs)
13248{
a9b3a50f
PA
13249 if (bs->breakpoint_at->type == bp_shlib_event)
13250 {
13251 /* If requested, stop when the dynamic linker notifies GDB of
13252 events. This allows the user to get control and place
13253 breakpoints in initializer routines for dynamically loaded
13254 objects (among other things). */
13255 bs->stop = stop_on_solib_events;
13256 bs->print = stop_on_solib_events;
13257 }
13258 else
13259 bs->stop = 0;
06edf0c0
PA
13260}
13261
13262static enum print_stop_action
13263internal_bkpt_print_it (bpstat bs)
13264{
06edf0c0 13265 struct breakpoint *b;
06edf0c0 13266
06edf0c0
PA
13267 b = bs->breakpoint_at;
13268
06edf0c0
PA
13269 switch (b->type)
13270 {
348d480f
PA
13271 case bp_shlib_event:
13272 /* Did we stop because the user set the stop_on_solib_events
13273 variable? (If so, we report this as a generic, "Stopped due
13274 to shlib event" message.) */
edcc5120 13275 print_solib_event (0);
348d480f
PA
13276 break;
13277
13278 case bp_thread_event:
13279 /* Not sure how we will get here.
13280 GDB should not stop for these breakpoints. */
13281 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
348d480f
PA
13282 break;
13283
13284 case bp_overlay_event:
13285 /* By analogy with the thread event, GDB should not stop for these. */
13286 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
348d480f
PA
13287 break;
13288
13289 case bp_longjmp_master:
13290 /* These should never be enabled. */
13291 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
348d480f
PA
13292 break;
13293
13294 case bp_std_terminate_master:
13295 /* These should never be enabled. */
13296 printf_filtered (_("std::terminate Master Breakpoint: "
13297 "gdb should not stop!\n"));
348d480f
PA
13298 break;
13299
13300 case bp_exception_master:
13301 /* These should never be enabled. */
13302 printf_filtered (_("Exception Master Breakpoint: "
13303 "gdb should not stop!\n"));
06edf0c0
PA
13304 break;
13305 }
13306
001c8c33 13307 return PRINT_NOTHING;
06edf0c0
PA
13308}
13309
13310static void
13311internal_bkpt_print_mention (struct breakpoint *b)
13312{
13313 /* Nothing to mention. These breakpoints are internal. */
13314}
13315
06edf0c0
PA
13316/* Virtual table for momentary breakpoints */
13317
13318static void
13319momentary_bkpt_re_set (struct breakpoint *b)
13320{
13321 /* Keep temporary breakpoints, which can be encountered when we step
4d1eb6b4 13322 over a dlopen call and solib_add is resetting the breakpoints.
06edf0c0
PA
13323 Otherwise these should have been blown away via the cleanup chain
13324 or by breakpoint_init_inferior when we rerun the executable. */
13325}
13326
13327static void
13328momentary_bkpt_check_status (bpstat bs)
13329{
13330 /* Nothing. The point of these breakpoints is causing a stop. */
13331}
13332
13333static enum print_stop_action
13334momentary_bkpt_print_it (bpstat bs)
13335{
001c8c33 13336 return PRINT_UNKNOWN;
348d480f
PA
13337}
13338
06edf0c0
PA
13339static void
13340momentary_bkpt_print_mention (struct breakpoint *b)
348d480f 13341{
06edf0c0 13342 /* Nothing to mention. These breakpoints are internal. */
348d480f
PA
13343}
13344
e2e4d78b
JK
13345/* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13346
13347 It gets cleared already on the removal of the first one of such placed
13348 breakpoints. This is OK as they get all removed altogether. */
13349
13350static void
13351longjmp_bkpt_dtor (struct breakpoint *self)
13352{
5d5658a1 13353 struct thread_info *tp = find_thread_global_id (self->thread);
e2e4d78b
JK
13354
13355 if (tp)
13356 tp->initiating_frame = null_frame_id;
13357
13358 momentary_breakpoint_ops.dtor (self);
13359}
13360
55aa24fb
SDJ
13361/* Specific methods for probe breakpoints. */
13362
13363static int
13364bkpt_probe_insert_location (struct bp_location *bl)
13365{
13366 int v = bkpt_insert_location (bl);
13367
13368 if (v == 0)
13369 {
13370 /* The insertion was successful, now let's set the probe's semaphore
13371 if needed. */
0ea5cda8
SDJ
13372 if (bl->probe.probe->pops->set_semaphore != NULL)
13373 bl->probe.probe->pops->set_semaphore (bl->probe.probe,
13374 bl->probe.objfile,
13375 bl->gdbarch);
55aa24fb
SDJ
13376 }
13377
13378 return v;
13379}
13380
13381static int
73971819
PA
13382bkpt_probe_remove_location (struct bp_location *bl,
13383 enum remove_bp_reason reason)
55aa24fb
SDJ
13384{
13385 /* Let's clear the semaphore before removing the location. */
0ea5cda8
SDJ
13386 if (bl->probe.probe->pops->clear_semaphore != NULL)
13387 bl->probe.probe->pops->clear_semaphore (bl->probe.probe,
13388 bl->probe.objfile,
13389 bl->gdbarch);
55aa24fb 13390
73971819 13391 return bkpt_remove_location (bl, reason);
55aa24fb
SDJ
13392}
13393
13394static void
f00aae0f 13395bkpt_probe_create_sals_from_location (const struct event_location *location,
5f700d83 13396 struct linespec_result *canonical,
f00aae0f 13397 enum bptype type_wanted)
55aa24fb
SDJ
13398{
13399 struct linespec_sals lsal;
13400
c2f4122d 13401 lsal.sals = parse_probes (location, NULL, canonical);
8e9e35b1
TT
13402 lsal.canonical
13403 = xstrdup (event_location_to_string (canonical->location.get ()));
55aa24fb
SDJ
13404 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13405}
13406
13407static void
f00aae0f
KS
13408bkpt_probe_decode_location (struct breakpoint *b,
13409 const struct event_location *location,
c2f4122d 13410 struct program_space *search_pspace,
55aa24fb
SDJ
13411 struct symtabs_and_lines *sals)
13412{
c2f4122d 13413 *sals = parse_probes (location, search_pspace, NULL);
55aa24fb
SDJ
13414 if (!sals->sals)
13415 error (_("probe not found"));
13416}
13417
348d480f 13418/* The breakpoint_ops structure to be used in tracepoints. */
876fa593 13419
348d480f
PA
13420static void
13421tracepoint_re_set (struct breakpoint *b)
13422{
13423 breakpoint_re_set_default (b);
13424}
876fa593 13425
348d480f
PA
13426static int
13427tracepoint_breakpoint_hit (const struct bp_location *bl,
09ac7c10
TT
13428 struct address_space *aspace, CORE_ADDR bp_addr,
13429 const struct target_waitstatus *ws)
348d480f
PA
13430{
13431 /* By definition, the inferior does not report stops at
13432 tracepoints. */
13433 return 0;
74960c60
VP
13434}
13435
13436static void
348d480f
PA
13437tracepoint_print_one_detail (const struct breakpoint *self,
13438 struct ui_out *uiout)
74960c60 13439{
d9b3f62e
PA
13440 struct tracepoint *tp = (struct tracepoint *) self;
13441 if (tp->static_trace_marker_id)
348d480f
PA
13442 {
13443 gdb_assert (self->type == bp_static_tracepoint);
cc59ec59 13444
112e8700
SM
13445 uiout->text ("\tmarker id is ");
13446 uiout->field_string ("static-tracepoint-marker-string-id",
d9b3f62e 13447 tp->static_trace_marker_id);
112e8700 13448 uiout->text ("\n");
348d480f 13449 }
0d381245
VP
13450}
13451
a474d7c2 13452static void
348d480f 13453tracepoint_print_mention (struct breakpoint *b)
a474d7c2 13454{
112e8700 13455 if (current_uiout->is_mi_like_p ())
348d480f 13456 return;
cc59ec59 13457
348d480f
PA
13458 switch (b->type)
13459 {
13460 case bp_tracepoint:
13461 printf_filtered (_("Tracepoint"));
13462 printf_filtered (_(" %d"), b->number);
13463 break;
13464 case bp_fast_tracepoint:
13465 printf_filtered (_("Fast tracepoint"));
13466 printf_filtered (_(" %d"), b->number);
13467 break;
13468 case bp_static_tracepoint:
13469 printf_filtered (_("Static tracepoint"));
13470 printf_filtered (_(" %d"), b->number);
13471 break;
13472 default:
13473 internal_error (__FILE__, __LINE__,
13474 _("unhandled tracepoint type %d"), (int) b->type);
13475 }
13476
13477 say_where (b);
a474d7c2
PA
13478}
13479
348d480f 13480static void
d9b3f62e 13481tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
a474d7c2 13482{
d9b3f62e
PA
13483 struct tracepoint *tp = (struct tracepoint *) self;
13484
13485 if (self->type == bp_fast_tracepoint)
348d480f 13486 fprintf_unfiltered (fp, "ftrace");
c93e8391 13487 else if (self->type == bp_static_tracepoint)
348d480f 13488 fprintf_unfiltered (fp, "strace");
d9b3f62e 13489 else if (self->type == bp_tracepoint)
348d480f
PA
13490 fprintf_unfiltered (fp, "trace");
13491 else
13492 internal_error (__FILE__, __LINE__,
d9b3f62e 13493 _("unhandled tracepoint type %d"), (int) self->type);
cc59ec59 13494
f00aae0f 13495 fprintf_unfiltered (fp, " %s",
d28cd78a 13496 event_location_to_string (self->location.get ()));
d9b3f62e
PA
13497 print_recreate_thread (self, fp);
13498
13499 if (tp->pass_count)
13500 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
a474d7c2
PA
13501}
13502
983af33b 13503static void
f00aae0f
KS
13504tracepoint_create_sals_from_location (const struct event_location *location,
13505 struct linespec_result *canonical,
13506 enum bptype type_wanted)
983af33b 13507{
f00aae0f 13508 create_sals_from_location_default (location, canonical, type_wanted);
983af33b
SDJ
13509}
13510
13511static void
13512tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
13513 struct linespec_result *canonical,
983af33b 13514 char *cond_string,
e7e0cddf 13515 char *extra_string,
983af33b
SDJ
13516 enum bptype type_wanted,
13517 enum bpdisp disposition,
13518 int thread,
13519 int task, int ignore_count,
13520 const struct breakpoint_ops *ops,
13521 int from_tty, int enabled,
44f238bb 13522 int internal, unsigned flags)
983af33b 13523{
023fa29b 13524 create_breakpoints_sal_default (gdbarch, canonical,
e7e0cddf
SS
13525 cond_string, extra_string,
13526 type_wanted,
983af33b
SDJ
13527 disposition, thread, task,
13528 ignore_count, ops, from_tty,
44f238bb 13529 enabled, internal, flags);
983af33b
SDJ
13530}
13531
13532static void
f00aae0f
KS
13533tracepoint_decode_location (struct breakpoint *b,
13534 const struct event_location *location,
c2f4122d 13535 struct program_space *search_pspace,
983af33b
SDJ
13536 struct symtabs_and_lines *sals)
13537{
c2f4122d 13538 decode_location_default (b, location, search_pspace, sals);
983af33b
SDJ
13539}
13540
2060206e 13541struct breakpoint_ops tracepoint_breakpoint_ops;
348d480f 13542
55aa24fb
SDJ
13543/* The breakpoint_ops structure to be use on tracepoints placed in a
13544 static probe. */
13545
13546static void
f00aae0f
KS
13547tracepoint_probe_create_sals_from_location
13548 (const struct event_location *location,
13549 struct linespec_result *canonical,
13550 enum bptype type_wanted)
55aa24fb
SDJ
13551{
13552 /* We use the same method for breakpoint on probes. */
f00aae0f 13553 bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
55aa24fb
SDJ
13554}
13555
13556static void
f00aae0f
KS
13557tracepoint_probe_decode_location (struct breakpoint *b,
13558 const struct event_location *location,
c2f4122d 13559 struct program_space *search_pspace,
55aa24fb
SDJ
13560 struct symtabs_and_lines *sals)
13561{
13562 /* We use the same method for breakpoint on probes. */
c2f4122d 13563 bkpt_probe_decode_location (b, location, search_pspace, sals);
55aa24fb
SDJ
13564}
13565
13566static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13567
5c2b4418
HZ
13568/* Dprintf breakpoint_ops methods. */
13569
13570static void
13571dprintf_re_set (struct breakpoint *b)
13572{
13573 breakpoint_re_set_default (b);
13574
f00aae0f
KS
13575 /* extra_string should never be non-NULL for dprintf. */
13576 gdb_assert (b->extra_string != NULL);
5c2b4418
HZ
13577
13578 /* 1 - connect to target 1, that can run breakpoint commands.
13579 2 - create a dprintf, which resolves fine.
13580 3 - disconnect from target 1
13581 4 - connect to target 2, that can NOT run breakpoint commands.
13582
13583 After steps #3/#4, you'll want the dprintf command list to
13584 be updated, because target 1 and 2 may well return different
13585 answers for target_can_run_breakpoint_commands().
13586 Given absence of finer grained resetting, we get to do
13587 it all the time. */
13588 if (b->extra_string != NULL)
13589 update_dprintf_command_list (b);
13590}
13591
2d9442cc
HZ
13592/* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13593
13594static void
13595dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13596{
f00aae0f 13597 fprintf_unfiltered (fp, "dprintf %s,%s",
d28cd78a 13598 event_location_to_string (tp->location.get ()),
2d9442cc
HZ
13599 tp->extra_string);
13600 print_recreate_thread (tp, fp);
13601}
13602
9d6e6e84
HZ
13603/* Implement the "after_condition_true" breakpoint_ops method for
13604 dprintf.
13605
13606 dprintf's are implemented with regular commands in their command
13607 list, but we run the commands here instead of before presenting the
13608 stop to the user, as dprintf's don't actually cause a stop. This
13609 also makes it so that the commands of multiple dprintfs at the same
13610 address are all handled. */
13611
13612static void
13613dprintf_after_condition_true (struct bpstats *bs)
13614{
13615 struct cleanup *old_chain;
13616 struct bpstats tmp_bs = { NULL };
13617 struct bpstats *tmp_bs_p = &tmp_bs;
13618
13619 /* dprintf's never cause a stop. This wasn't set in the
13620 check_status hook instead because that would make the dprintf's
13621 condition not be evaluated. */
13622 bs->stop = 0;
13623
13624 /* Run the command list here. Take ownership of it instead of
13625 copying. We never want these commands to run later in
13626 bpstat_do_actions, if a breakpoint that causes a stop happens to
13627 be set at same address as this dprintf, or even if running the
13628 commands here throws. */
13629 tmp_bs.commands = bs->commands;
13630 bs->commands = NULL;
13631 old_chain = make_cleanup_decref_counted_command_line (&tmp_bs.commands);
13632
13633 bpstat_do_actions_1 (&tmp_bs_p);
13634
13635 /* 'tmp_bs.commands' will usually be NULL by now, but
13636 bpstat_do_actions_1 may return early without processing the whole
13637 list. */
13638 do_cleanups (old_chain);
13639}
13640
983af33b
SDJ
13641/* The breakpoint_ops structure to be used on static tracepoints with
13642 markers (`-m'). */
13643
13644static void
f00aae0f 13645strace_marker_create_sals_from_location (const struct event_location *location,
5f700d83 13646 struct linespec_result *canonical,
f00aae0f 13647 enum bptype type_wanted)
983af33b
SDJ
13648{
13649 struct linespec_sals lsal;
f00aae0f
KS
13650 const char *arg_start, *arg;
13651 char *str;
13652 struct cleanup *cleanup;
983af33b 13653
f00aae0f
KS
13654 arg = arg_start = get_linespec_location (location);
13655 lsal.sals = decode_static_tracepoint_spec (&arg);
983af33b 13656
f00aae0f
KS
13657 str = savestring (arg_start, arg - arg_start);
13658 cleanup = make_cleanup (xfree, str);
8e9e35b1 13659 canonical->location = new_linespec_location (&str);
f00aae0f 13660 do_cleanups (cleanup);
983af33b 13661
8e9e35b1
TT
13662 lsal.canonical
13663 = xstrdup (event_location_to_string (canonical->location.get ()));
983af33b
SDJ
13664 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13665}
13666
13667static void
13668strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13669 struct linespec_result *canonical,
983af33b 13670 char *cond_string,
e7e0cddf 13671 char *extra_string,
983af33b
SDJ
13672 enum bptype type_wanted,
13673 enum bpdisp disposition,
13674 int thread,
13675 int task, int ignore_count,
13676 const struct breakpoint_ops *ops,
13677 int from_tty, int enabled,
44f238bb 13678 int internal, unsigned flags)
983af33b
SDJ
13679{
13680 int i;
52d361e1
YQ
13681 struct linespec_sals *lsal = VEC_index (linespec_sals,
13682 canonical->sals, 0);
983af33b
SDJ
13683
13684 /* If the user is creating a static tracepoint by marker id
13685 (strace -m MARKER_ID), then store the sals index, so that
13686 breakpoint_re_set can try to match up which of the newly
13687 found markers corresponds to this one, and, don't try to
13688 expand multiple locations for each sal, given than SALS
13689 already should contain all sals for MARKER_ID. */
13690
13691 for (i = 0; i < lsal->sals.nelts; ++i)
13692 {
13693 struct symtabs_and_lines expanded;
13694 struct tracepoint *tp;
ffc2605c 13695 event_location_up location;
983af33b
SDJ
13696
13697 expanded.nelts = 1;
13698 expanded.sals = &lsal->sals.sals[i];
13699
8e9e35b1 13700 location = copy_event_location (canonical->location.get ());
983af33b 13701
4d01a485 13702 tp = new tracepoint ();
983af33b 13703 init_breakpoint_sal (&tp->base, gdbarch, expanded,
ffc2605c 13704 std::move (location), NULL,
e7e0cddf
SS
13705 cond_string, extra_string,
13706 type_wanted, disposition,
983af33b 13707 thread, task, ignore_count, ops,
44f238bb 13708 from_tty, enabled, internal, flags,
983af33b
SDJ
13709 canonical->special_display);
13710 /* Given that its possible to have multiple markers with
13711 the same string id, if the user is creating a static
13712 tracepoint by marker id ("strace -m MARKER_ID"), then
13713 store the sals index, so that breakpoint_re_set can
13714 try to match up which of the newly found markers
13715 corresponds to this one */
13716 tp->static_trace_marker_id_idx = i;
13717
13718 install_breakpoint (internal, &tp->base, 0);
983af33b
SDJ
13719 }
13720}
13721
13722static void
f00aae0f
KS
13723strace_marker_decode_location (struct breakpoint *b,
13724 const struct event_location *location,
c2f4122d 13725 struct program_space *search_pspace,
983af33b
SDJ
13726 struct symtabs_and_lines *sals)
13727{
13728 struct tracepoint *tp = (struct tracepoint *) b;
f00aae0f 13729 const char *s = get_linespec_location (location);
983af33b 13730
f00aae0f 13731 *sals = decode_static_tracepoint_spec (&s);
983af33b
SDJ
13732 if (sals->nelts > tp->static_trace_marker_id_idx)
13733 {
13734 sals->sals[0] = sals->sals[tp->static_trace_marker_id_idx];
13735 sals->nelts = 1;
13736 }
13737 else
13738 error (_("marker %s not found"), tp->static_trace_marker_id);
13739}
13740
13741static struct breakpoint_ops strace_marker_breakpoint_ops;
13742
13743static int
13744strace_marker_p (struct breakpoint *b)
13745{
13746 return b->ops == &strace_marker_breakpoint_ops;
13747}
13748
53a5351d 13749/* Delete a breakpoint and clean up all traces of it in the data
f431efe5 13750 structures. */
c906108c
SS
13751
13752void
fba45db2 13753delete_breakpoint (struct breakpoint *bpt)
c906108c 13754{
52f0bd74 13755 struct breakpoint *b;
c906108c 13756
8a3fe4f8 13757 gdb_assert (bpt != NULL);
c906108c 13758
4a64f543
MS
13759 /* Has this bp already been deleted? This can happen because
13760 multiple lists can hold pointers to bp's. bpstat lists are
13761 especial culprits.
13762
13763 One example of this happening is a watchpoint's scope bp. When
13764 the scope bp triggers, we notice that the watchpoint is out of
13765 scope, and delete it. We also delete its scope bp. But the
13766 scope bp is marked "auto-deleting", and is already on a bpstat.
13767 That bpstat is then checked for auto-deleting bp's, which are
13768 deleted.
13769
13770 A real solution to this problem might involve reference counts in
13771 bp's, and/or giving them pointers back to their referencing
13772 bpstat's, and teaching delete_breakpoint to only free a bp's
13773 storage when no more references were extent. A cheaper bandaid
13774 was chosen. */
c906108c
SS
13775 if (bpt->type == bp_none)
13776 return;
13777
4a64f543
MS
13778 /* At least avoid this stale reference until the reference counting
13779 of breakpoints gets resolved. */
d0fb5eae 13780 if (bpt->related_breakpoint != bpt)
e5a0a904 13781 {
d0fb5eae 13782 struct breakpoint *related;
3a5c3e22 13783 struct watchpoint *w;
d0fb5eae
JK
13784
13785 if (bpt->type == bp_watchpoint_scope)
3a5c3e22 13786 w = (struct watchpoint *) bpt->related_breakpoint;
d0fb5eae 13787 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
3a5c3e22
PA
13788 w = (struct watchpoint *) bpt;
13789 else
13790 w = NULL;
13791 if (w != NULL)
13792 watchpoint_del_at_next_stop (w);
d0fb5eae
JK
13793
13794 /* Unlink bpt from the bpt->related_breakpoint ring. */
13795 for (related = bpt; related->related_breakpoint != bpt;
13796 related = related->related_breakpoint);
13797 related->related_breakpoint = bpt->related_breakpoint;
13798 bpt->related_breakpoint = bpt;
e5a0a904
JK
13799 }
13800
a9634178
TJB
13801 /* watch_command_1 creates a watchpoint but only sets its number if
13802 update_watchpoint succeeds in creating its bp_locations. If there's
13803 a problem in that process, we'll be asked to delete the half-created
13804 watchpoint. In that case, don't announce the deletion. */
13805 if (bpt->number)
13806 observer_notify_breakpoint_deleted (bpt);
c906108c 13807
c906108c
SS
13808 if (breakpoint_chain == bpt)
13809 breakpoint_chain = bpt->next;
13810
c906108c
SS
13811 ALL_BREAKPOINTS (b)
13812 if (b->next == bpt)
c5aa993b
JM
13813 {
13814 b->next = bpt->next;
13815 break;
13816 }
c906108c 13817
f431efe5
PA
13818 /* Be sure no bpstat's are pointing at the breakpoint after it's
13819 been freed. */
13820 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
e5dd4106 13821 in all threads for now. Note that we cannot just remove bpstats
f431efe5
PA
13822 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13823 commands are associated with the bpstat; if we remove it here,
13824 then the later call to bpstat_do_actions (&stop_bpstat); in
13825 event-top.c won't do anything, and temporary breakpoints with
13826 commands won't work. */
13827
13828 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13829
4a64f543
MS
13830 /* Now that breakpoint is removed from breakpoint list, update the
13831 global location list. This will remove locations that used to
13832 belong to this breakpoint. Do this before freeing the breakpoint
13833 itself, since remove_breakpoint looks at location's owner. It
13834 might be better design to have location completely
13835 self-contained, but it's not the case now. */
44702360 13836 update_global_location_list (UGLL_DONT_INSERT);
74960c60 13837
348d480f 13838 bpt->ops->dtor (bpt);
4a64f543
MS
13839 /* On the chance that someone will soon try again to delete this
13840 same bp, we mark it as deleted before freeing its storage. */
c906108c 13841 bpt->type = bp_none;
4d01a485 13842 delete bpt;
c906108c
SS
13843}
13844
4d6140d9
AC
13845static void
13846do_delete_breakpoint_cleanup (void *b)
13847{
9a3c8263 13848 delete_breakpoint ((struct breakpoint *) b);
4d6140d9
AC
13849}
13850
13851struct cleanup *
13852make_cleanup_delete_breakpoint (struct breakpoint *b)
13853{
13854 return make_cleanup (do_delete_breakpoint_cleanup, b);
13855}
13856
51be5b68
PA
13857/* Iterator function to call a user-provided callback function once
13858 for each of B and its related breakpoints. */
13859
13860static void
13861iterate_over_related_breakpoints (struct breakpoint *b,
13862 void (*function) (struct breakpoint *,
13863 void *),
13864 void *data)
13865{
13866 struct breakpoint *related;
13867
13868 related = b;
13869 do
13870 {
13871 struct breakpoint *next;
13872
13873 /* FUNCTION may delete RELATED. */
13874 next = related->related_breakpoint;
13875
13876 if (next == related)
13877 {
13878 /* RELATED is the last ring entry. */
13879 function (related, data);
13880
13881 /* FUNCTION may have deleted it, so we'd never reach back to
13882 B. There's nothing left to do anyway, so just break
13883 out. */
13884 break;
13885 }
13886 else
13887 function (related, data);
13888
13889 related = next;
13890 }
13891 while (related != b);
13892}
95a42b64
TT
13893
13894static void
13895do_delete_breakpoint (struct breakpoint *b, void *ignore)
13896{
13897 delete_breakpoint (b);
13898}
13899
51be5b68
PA
13900/* A callback for map_breakpoint_numbers that calls
13901 delete_breakpoint. */
13902
13903static void
13904do_map_delete_breakpoint (struct breakpoint *b, void *ignore)
13905{
13906 iterate_over_related_breakpoints (b, do_delete_breakpoint, NULL);
13907}
13908
c906108c 13909void
fba45db2 13910delete_command (char *arg, int from_tty)
c906108c 13911{
35df4500 13912 struct breakpoint *b, *b_tmp;
c906108c 13913
ea9365bb
TT
13914 dont_repeat ();
13915
c906108c
SS
13916 if (arg == 0)
13917 {
13918 int breaks_to_delete = 0;
13919
46c6471b
PA
13920 /* Delete all breakpoints if no argument. Do not delete
13921 internal breakpoints, these have to be deleted with an
13922 explicit breakpoint number argument. */
c5aa993b 13923 ALL_BREAKPOINTS (b)
46c6471b 13924 if (user_breakpoint_p (b))
973d738b
DJ
13925 {
13926 breaks_to_delete = 1;
13927 break;
13928 }
c906108c
SS
13929
13930 /* Ask user only if there are some breakpoints to delete. */
13931 if (!from_tty
e2e0b3e5 13932 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
c906108c 13933 {
35df4500 13934 ALL_BREAKPOINTS_SAFE (b, b_tmp)
46c6471b 13935 if (user_breakpoint_p (b))
c5aa993b 13936 delete_breakpoint (b);
c906108c
SS
13937 }
13938 }
13939 else
51be5b68 13940 map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
c906108c
SS
13941}
13942
c2f4122d
PA
13943/* Return true if all locations of B bound to PSPACE are pending. If
13944 PSPACE is NULL, all locations of all program spaces are
13945 considered. */
13946
0d381245 13947static int
c2f4122d 13948all_locations_are_pending (struct breakpoint *b, struct program_space *pspace)
fe3f5fa8 13949{
c2f4122d
PA
13950 struct bp_location *loc;
13951
13952 for (loc = b->loc; loc != NULL; loc = loc->next)
13953 if ((pspace == NULL
13954 || loc->pspace == pspace)
13955 && !loc->shlib_disabled
8645ff69 13956 && !loc->pspace->executing_startup)
0d381245
VP
13957 return 0;
13958 return 1;
fe3f5fa8
VP
13959}
13960
776592bf
DE
13961/* Subroutine of update_breakpoint_locations to simplify it.
13962 Return non-zero if multiple fns in list LOC have the same name.
13963 Null names are ignored. */
13964
13965static int
13966ambiguous_names_p (struct bp_location *loc)
13967{
13968 struct bp_location *l;
13969 htab_t htab = htab_create_alloc (13, htab_hash_string,
cc59ec59
MS
13970 (int (*) (const void *,
13971 const void *)) streq,
776592bf
DE
13972 NULL, xcalloc, xfree);
13973
13974 for (l = loc; l != NULL; l = l->next)
13975 {
13976 const char **slot;
13977 const char *name = l->function_name;
13978
13979 /* Allow for some names to be NULL, ignore them. */
13980 if (name == NULL)
13981 continue;
13982
13983 slot = (const char **) htab_find_slot (htab, (const void *) name,
13984 INSERT);
4a64f543
MS
13985 /* NOTE: We can assume slot != NULL here because xcalloc never
13986 returns NULL. */
776592bf
DE
13987 if (*slot != NULL)
13988 {
13989 htab_delete (htab);
13990 return 1;
13991 }
13992 *slot = name;
13993 }
13994
13995 htab_delete (htab);
13996 return 0;
13997}
13998
0fb4aa4b
PA
13999/* When symbols change, it probably means the sources changed as well,
14000 and it might mean the static tracepoint markers are no longer at
14001 the same address or line numbers they used to be at last we
14002 checked. Losing your static tracepoints whenever you rebuild is
14003 undesirable. This function tries to resync/rematch gdb static
14004 tracepoints with the markers on the target, for static tracepoints
14005 that have not been set by marker id. Static tracepoint that have
14006 been set by marker id are reset by marker id in breakpoint_re_set.
14007 The heuristic is:
14008
14009 1) For a tracepoint set at a specific address, look for a marker at
14010 the old PC. If one is found there, assume to be the same marker.
14011 If the name / string id of the marker found is different from the
14012 previous known name, assume that means the user renamed the marker
14013 in the sources, and output a warning.
14014
14015 2) For a tracepoint set at a given line number, look for a marker
14016 at the new address of the old line number. If one is found there,
14017 assume to be the same marker. If the name / string id of the
14018 marker found is different from the previous known name, assume that
14019 means the user renamed the marker in the sources, and output a
14020 warning.
14021
14022 3) If a marker is no longer found at the same address or line, it
14023 may mean the marker no longer exists. But it may also just mean
14024 the code changed a bit. Maybe the user added a few lines of code
14025 that made the marker move up or down (in line number terms). Ask
14026 the target for info about the marker with the string id as we knew
14027 it. If found, update line number and address in the matching
14028 static tracepoint. This will get confused if there's more than one
14029 marker with the same ID (possible in UST, although unadvised
14030 precisely because it confuses tools). */
14031
14032static struct symtab_and_line
14033update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
14034{
d9b3f62e 14035 struct tracepoint *tp = (struct tracepoint *) b;
0fb4aa4b
PA
14036 struct static_tracepoint_marker marker;
14037 CORE_ADDR pc;
0fb4aa4b
PA
14038
14039 pc = sal.pc;
14040 if (sal.line)
14041 find_line_pc (sal.symtab, sal.line, &pc);
14042
14043 if (target_static_tracepoint_marker_at (pc, &marker))
14044 {
d9b3f62e 14045 if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
0fb4aa4b
PA
14046 warning (_("static tracepoint %d changed probed marker from %s to %s"),
14047 b->number,
d9b3f62e 14048 tp->static_trace_marker_id, marker.str_id);
0fb4aa4b 14049
d9b3f62e
PA
14050 xfree (tp->static_trace_marker_id);
14051 tp->static_trace_marker_id = xstrdup (marker.str_id);
0fb4aa4b
PA
14052 release_static_tracepoint_marker (&marker);
14053
14054 return sal;
14055 }
14056
14057 /* Old marker wasn't found on target at lineno. Try looking it up
14058 by string ID. */
14059 if (!sal.explicit_pc
14060 && sal.line != 0
14061 && sal.symtab != NULL
d9b3f62e 14062 && tp->static_trace_marker_id != NULL)
0fb4aa4b
PA
14063 {
14064 VEC(static_tracepoint_marker_p) *markers;
14065
14066 markers
d9b3f62e 14067 = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
0fb4aa4b
PA
14068
14069 if (!VEC_empty(static_tracepoint_marker_p, markers))
14070 {
80e1d417 14071 struct symtab_and_line sal2;
0fb4aa4b 14072 struct symbol *sym;
80e1d417 14073 struct static_tracepoint_marker *tpmarker;
79a45e25 14074 struct ui_out *uiout = current_uiout;
67994074 14075 struct explicit_location explicit_loc;
0fb4aa4b 14076
80e1d417 14077 tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
0fb4aa4b 14078
d9b3f62e 14079 xfree (tp->static_trace_marker_id);
80e1d417 14080 tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
0fb4aa4b
PA
14081
14082 warning (_("marker for static tracepoint %d (%s) not "
14083 "found at previous line number"),
d9b3f62e 14084 b->number, tp->static_trace_marker_id);
0fb4aa4b 14085
80e1d417 14086 init_sal (&sal2);
0fb4aa4b 14087
80e1d417 14088 sal2.pc = tpmarker->address;
0fb4aa4b 14089
80e1d417
AS
14090 sal2 = find_pc_line (tpmarker->address, 0);
14091 sym = find_pc_sect_function (tpmarker->address, NULL);
112e8700 14092 uiout->text ("Now in ");
0fb4aa4b
PA
14093 if (sym)
14094 {
112e8700
SM
14095 uiout->field_string ("func", SYMBOL_PRINT_NAME (sym));
14096 uiout->text (" at ");
0fb4aa4b 14097 }
112e8700 14098 uiout->field_string ("file",
05cba821 14099 symtab_to_filename_for_display (sal2.symtab));
112e8700 14100 uiout->text (":");
0fb4aa4b 14101
112e8700 14102 if (uiout->is_mi_like_p ())
0fb4aa4b 14103 {
0b0865da 14104 const char *fullname = symtab_to_fullname (sal2.symtab);
0fb4aa4b 14105
112e8700 14106 uiout->field_string ("fullname", fullname);
0fb4aa4b
PA
14107 }
14108
112e8700
SM
14109 uiout->field_int ("line", sal2.line);
14110 uiout->text ("\n");
0fb4aa4b 14111
80e1d417 14112 b->loc->line_number = sal2.line;
2f202fde 14113 b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
0fb4aa4b 14114
d28cd78a 14115 b->location.reset (NULL);
67994074
KS
14116 initialize_explicit_location (&explicit_loc);
14117 explicit_loc.source_filename
00e52e53 14118 = ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
67994074
KS
14119 explicit_loc.line_offset.offset = b->loc->line_number;
14120 explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
d28cd78a 14121 b->location = new_explicit_location (&explicit_loc);
0fb4aa4b
PA
14122
14123 /* Might be nice to check if function changed, and warn if
14124 so. */
14125
80e1d417 14126 release_static_tracepoint_marker (tpmarker);
0fb4aa4b
PA
14127 }
14128 }
14129 return sal;
14130}
14131
8d3788bd
VP
14132/* Returns 1 iff locations A and B are sufficiently same that
14133 we don't need to report breakpoint as changed. */
14134
14135static int
14136locations_are_equal (struct bp_location *a, struct bp_location *b)
14137{
14138 while (a && b)
14139 {
14140 if (a->address != b->address)
14141 return 0;
14142
14143 if (a->shlib_disabled != b->shlib_disabled)
14144 return 0;
14145
14146 if (a->enabled != b->enabled)
14147 return 0;
14148
14149 a = a->next;
14150 b = b->next;
14151 }
14152
14153 if ((a == NULL) != (b == NULL))
14154 return 0;
14155
14156 return 1;
14157}
14158
c2f4122d
PA
14159/* Split all locations of B that are bound to PSPACE out of B's
14160 location list to a separate list and return that list's head. If
14161 PSPACE is NULL, hoist out all locations of B. */
14162
14163static struct bp_location *
14164hoist_existing_locations (struct breakpoint *b, struct program_space *pspace)
14165{
14166 struct bp_location head;
14167 struct bp_location *i = b->loc;
14168 struct bp_location **i_link = &b->loc;
14169 struct bp_location *hoisted = &head;
14170
14171 if (pspace == NULL)
14172 {
14173 i = b->loc;
14174 b->loc = NULL;
14175 return i;
14176 }
14177
14178 head.next = NULL;
14179
14180 while (i != NULL)
14181 {
14182 if (i->pspace == pspace)
14183 {
14184 *i_link = i->next;
14185 i->next = NULL;
14186 hoisted->next = i;
14187 hoisted = i;
14188 }
14189 else
14190 i_link = &i->next;
14191 i = *i_link;
14192 }
14193
14194 return head.next;
14195}
14196
14197/* Create new breakpoint locations for B (a hardware or software
14198 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
14199 zero, then B is a ranged breakpoint. Only recreates locations for
14200 FILTER_PSPACE. Locations of other program spaces are left
14201 untouched. */
f1310107 14202
0e30163f 14203void
0d381245 14204update_breakpoint_locations (struct breakpoint *b,
c2f4122d 14205 struct program_space *filter_pspace,
f1310107
TJB
14206 struct symtabs_and_lines sals,
14207 struct symtabs_and_lines sals_end)
fe3f5fa8
VP
14208{
14209 int i;
c2f4122d 14210 struct bp_location *existing_locations;
0d381245 14211
f8eba3c6
TT
14212 if (sals_end.nelts != 0 && (sals.nelts != 1 || sals_end.nelts != 1))
14213 {
14214 /* Ranged breakpoints have only one start location and one end
14215 location. */
14216 b->enable_state = bp_disabled;
f8eba3c6
TT
14217 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14218 "multiple locations found\n"),
14219 b->number);
14220 return;
14221 }
f1310107 14222
4a64f543
MS
14223 /* If there's no new locations, and all existing locations are
14224 pending, don't do anything. This optimizes the common case where
14225 all locations are in the same shared library, that was unloaded.
14226 We'd like to retain the location, so that when the library is
14227 loaded again, we don't loose the enabled/disabled status of the
14228 individual locations. */
c2f4122d 14229 if (all_locations_are_pending (b, filter_pspace) && sals.nelts == 0)
fe3f5fa8
VP
14230 return;
14231
c2f4122d 14232 existing_locations = hoist_existing_locations (b, filter_pspace);
fe3f5fa8 14233
0d381245 14234 for (i = 0; i < sals.nelts; ++i)
fe3f5fa8 14235 {
f8eba3c6
TT
14236 struct bp_location *new_loc;
14237
14238 switch_to_program_space_and_thread (sals.sals[i].pspace);
14239
14240 new_loc = add_location_to_breakpoint (b, &(sals.sals[i]));
fe3f5fa8 14241
0d381245
VP
14242 /* Reparse conditions, they might contain references to the
14243 old symtab. */
14244 if (b->cond_string != NULL)
14245 {
bbc13ae3 14246 const char *s;
fe3f5fa8 14247
0d381245 14248 s = b->cond_string;
492d29ea 14249 TRY
0d381245 14250 {
1bb9788d
TT
14251 new_loc->cond = parse_exp_1 (&s, sals.sals[i].pc,
14252 block_for_pc (sals.sals[i].pc),
0d381245
VP
14253 0);
14254 }
492d29ea 14255 CATCH (e, RETURN_MASK_ERROR)
0d381245 14256 {
3e43a32a
MS
14257 warning (_("failed to reevaluate condition "
14258 "for breakpoint %d: %s"),
0d381245
VP
14259 b->number, e.message);
14260 new_loc->enabled = 0;
14261 }
492d29ea 14262 END_CATCH
0d381245 14263 }
fe3f5fa8 14264
f1310107
TJB
14265 if (sals_end.nelts)
14266 {
14267 CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
14268
14269 new_loc->length = end - sals.sals[0].pc + 1;
14270 }
0d381245 14271 }
fe3f5fa8 14272
4a64f543
MS
14273 /* If possible, carry over 'disable' status from existing
14274 breakpoints. */
0d381245
VP
14275 {
14276 struct bp_location *e = existing_locations;
776592bf
DE
14277 /* If there are multiple breakpoints with the same function name,
14278 e.g. for inline functions, comparing function names won't work.
14279 Instead compare pc addresses; this is just a heuristic as things
14280 may have moved, but in practice it gives the correct answer
14281 often enough until a better solution is found. */
14282 int have_ambiguous_names = ambiguous_names_p (b->loc);
14283
0d381245
VP
14284 for (; e; e = e->next)
14285 {
14286 if (!e->enabled && e->function_name)
14287 {
14288 struct bp_location *l = b->loc;
776592bf
DE
14289 if (have_ambiguous_names)
14290 {
14291 for (; l; l = l->next)
f1310107 14292 if (breakpoint_locations_match (e, l))
776592bf
DE
14293 {
14294 l->enabled = 0;
14295 break;
14296 }
14297 }
14298 else
14299 {
14300 for (; l; l = l->next)
14301 if (l->function_name
14302 && strcmp (e->function_name, l->function_name) == 0)
14303 {
14304 l->enabled = 0;
14305 break;
14306 }
14307 }
0d381245
VP
14308 }
14309 }
14310 }
fe3f5fa8 14311
8d3788bd
VP
14312 if (!locations_are_equal (existing_locations, b->loc))
14313 observer_notify_breakpoint_modified (b);
fe3f5fa8
VP
14314}
14315
f00aae0f 14316/* Find the SaL locations corresponding to the given LOCATION.
ef23e705
TJB
14317 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14318
14319static struct symtabs_and_lines
f00aae0f 14320location_to_sals (struct breakpoint *b, struct event_location *location,
c2f4122d 14321 struct program_space *search_pspace, int *found)
ef23e705 14322{
02d20e4a 14323 struct symtabs_and_lines sals = {0};
492d29ea 14324 struct gdb_exception exception = exception_none;
ef23e705 14325
983af33b 14326 gdb_assert (b->ops != NULL);
ef23e705 14327
492d29ea 14328 TRY
ef23e705 14329 {
c2f4122d 14330 b->ops->decode_location (b, location, search_pspace, &sals);
ef23e705 14331 }
492d29ea 14332 CATCH (e, RETURN_MASK_ERROR)
ef23e705
TJB
14333 {
14334 int not_found_and_ok = 0;
492d29ea
PA
14335
14336 exception = e;
14337
ef23e705
TJB
14338 /* For pending breakpoints, it's expected that parsing will
14339 fail until the right shared library is loaded. User has
14340 already told to create pending breakpoints and don't need
14341 extra messages. If breakpoint is in bp_shlib_disabled
14342 state, then user already saw the message about that
14343 breakpoint being disabled, and don't want to see more
14344 errors. */
58438ac1 14345 if (e.error == NOT_FOUND_ERROR
c2f4122d
PA
14346 && (b->condition_not_parsed
14347 || (b->loc != NULL
14348 && search_pspace != NULL
14349 && b->loc->pspace != search_pspace)
ef23e705 14350 || (b->loc && b->loc->shlib_disabled)
f8eba3c6 14351 || (b->loc && b->loc->pspace->executing_startup)
ef23e705
TJB
14352 || b->enable_state == bp_disabled))
14353 not_found_and_ok = 1;
14354
14355 if (!not_found_and_ok)
14356 {
14357 /* We surely don't want to warn about the same breakpoint
14358 10 times. One solution, implemented here, is disable
14359 the breakpoint on error. Another solution would be to
14360 have separate 'warning emitted' flag. Since this
14361 happens only when a binary has changed, I don't know
14362 which approach is better. */
14363 b->enable_state = bp_disabled;
14364 throw_exception (e);
14365 }
14366 }
492d29ea 14367 END_CATCH
ef23e705 14368
492d29ea 14369 if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
ef23e705 14370 {
f8eba3c6 14371 int i;
ef23e705 14372
f8eba3c6
TT
14373 for (i = 0; i < sals.nelts; ++i)
14374 resolve_sal_pc (&sals.sals[i]);
f00aae0f 14375 if (b->condition_not_parsed && b->extra_string != NULL)
ef23e705 14376 {
ed1d1739
KS
14377 char *cond_string, *extra_string;
14378 int thread, task;
ef23e705 14379
f00aae0f 14380 find_condition_and_thread (b->extra_string, sals.sals[0].pc,
e7e0cddf
SS
14381 &cond_string, &thread, &task,
14382 &extra_string);
f00aae0f 14383 gdb_assert (b->cond_string == NULL);
ef23e705
TJB
14384 if (cond_string)
14385 b->cond_string = cond_string;
14386 b->thread = thread;
14387 b->task = task;
e7e0cddf 14388 if (extra_string)
f00aae0f
KS
14389 {
14390 xfree (b->extra_string);
14391 b->extra_string = extra_string;
14392 }
ef23e705
TJB
14393 b->condition_not_parsed = 0;
14394 }
14395
983af33b 14396 if (b->type == bp_static_tracepoint && !strace_marker_p (b))
ef23e705 14397 sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
ef23e705 14398
58438ac1
TT
14399 *found = 1;
14400 }
14401 else
14402 *found = 0;
ef23e705
TJB
14403
14404 return sals;
14405}
14406
348d480f
PA
14407/* The default re_set method, for typical hardware or software
14408 breakpoints. Reevaluate the breakpoint and recreate its
14409 locations. */
14410
14411static void
28010a5d 14412breakpoint_re_set_default (struct breakpoint *b)
ef23e705
TJB
14413{
14414 int found;
f1310107 14415 struct symtabs_and_lines sals, sals_end;
ef23e705 14416 struct symtabs_and_lines expanded = {0};
f1310107 14417 struct symtabs_and_lines expanded_end = {0};
c2f4122d 14418 struct program_space *filter_pspace = current_program_space;
ef23e705 14419
d28cd78a 14420 sals = location_to_sals (b, b->location.get (), filter_pspace, &found);
ef23e705
TJB
14421 if (found)
14422 {
14423 make_cleanup (xfree, sals.sals);
f8eba3c6 14424 expanded = sals;
ef23e705
TJB
14425 }
14426
f00aae0f 14427 if (b->location_range_end != NULL)
f1310107 14428 {
d28cd78a 14429 sals_end = location_to_sals (b, b->location_range_end.get (),
c2f4122d 14430 filter_pspace, &found);
f1310107
TJB
14431 if (found)
14432 {
14433 make_cleanup (xfree, sals_end.sals);
f8eba3c6 14434 expanded_end = sals_end;
f1310107
TJB
14435 }
14436 }
14437
c2f4122d 14438 update_breakpoint_locations (b, filter_pspace, expanded, expanded_end);
28010a5d
PA
14439}
14440
983af33b
SDJ
14441/* Default method for creating SALs from an address string. It basically
14442 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14443
14444static void
f00aae0f
KS
14445create_sals_from_location_default (const struct event_location *location,
14446 struct linespec_result *canonical,
14447 enum bptype type_wanted)
983af33b 14448{
f00aae0f 14449 parse_breakpoint_sals (location, canonical);
983af33b
SDJ
14450}
14451
14452/* Call create_breakpoints_sal for the given arguments. This is the default
14453 function for the `create_breakpoints_sal' method of
14454 breakpoint_ops. */
14455
14456static void
14457create_breakpoints_sal_default (struct gdbarch *gdbarch,
14458 struct linespec_result *canonical,
983af33b 14459 char *cond_string,
e7e0cddf 14460 char *extra_string,
983af33b
SDJ
14461 enum bptype type_wanted,
14462 enum bpdisp disposition,
14463 int thread,
14464 int task, int ignore_count,
14465 const struct breakpoint_ops *ops,
14466 int from_tty, int enabled,
44f238bb 14467 int internal, unsigned flags)
983af33b
SDJ
14468{
14469 create_breakpoints_sal (gdbarch, canonical, cond_string,
e7e0cddf 14470 extra_string,
983af33b
SDJ
14471 type_wanted, disposition,
14472 thread, task, ignore_count, ops, from_tty,
44f238bb 14473 enabled, internal, flags);
983af33b
SDJ
14474}
14475
14476/* Decode the line represented by S by calling decode_line_full. This is the
5f700d83 14477 default function for the `decode_location' method of breakpoint_ops. */
983af33b
SDJ
14478
14479static void
f00aae0f
KS
14480decode_location_default (struct breakpoint *b,
14481 const struct event_location *location,
c2f4122d 14482 struct program_space *search_pspace,
983af33b
SDJ
14483 struct symtabs_and_lines *sals)
14484{
14485 struct linespec_result canonical;
14486
c2f4122d 14487 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
983af33b
SDJ
14488 (struct symtab *) NULL, 0,
14489 &canonical, multiple_symbols_all,
14490 b->filter);
14491
14492 /* We should get 0 or 1 resulting SALs. */
14493 gdb_assert (VEC_length (linespec_sals, canonical.sals) < 2);
14494
14495 if (VEC_length (linespec_sals, canonical.sals) > 0)
14496 {
14497 struct linespec_sals *lsal;
14498
14499 lsal = VEC_index (linespec_sals, canonical.sals, 0);
14500 *sals = lsal->sals;
14501 /* Arrange it so the destructor does not free the
14502 contents. */
14503 lsal->sals.sals = NULL;
14504 }
983af33b
SDJ
14505}
14506
28010a5d
PA
14507/* Prepare the global context for a re-set of breakpoint B. */
14508
14509static struct cleanup *
14510prepare_re_set_context (struct breakpoint *b)
14511{
28010a5d 14512 input_radix = b->input_radix;
28010a5d
PA
14513 set_language (b->language);
14514
c2f4122d 14515 return make_cleanup (null_cleanup, NULL);
ef23e705
TJB
14516}
14517
c906108c
SS
14518/* Reset a breakpoint given it's struct breakpoint * BINT.
14519 The value we return ends up being the return value from catch_errors.
14520 Unused in this case. */
14521
14522static int
4efb68b1 14523breakpoint_re_set_one (void *bint)
c906108c 14524{
4a64f543 14525 /* Get past catch_errs. */
53a5351d 14526 struct breakpoint *b = (struct breakpoint *) bint;
348d480f 14527 struct cleanup *cleanups;
c906108c 14528
348d480f
PA
14529 cleanups = prepare_re_set_context (b);
14530 b->ops->re_set (b);
14531 do_cleanups (cleanups);
c906108c
SS
14532 return 0;
14533}
14534
c2f4122d
PA
14535/* Re-set breakpoint locations for the current program space.
14536 Locations bound to other program spaces are left untouched. */
14537
c906108c 14538void
69de3c6a 14539breakpoint_re_set (void)
c906108c 14540{
35df4500 14541 struct breakpoint *b, *b_tmp;
c906108c
SS
14542 enum language save_language;
14543 int save_input_radix;
6c95b8df 14544 struct cleanup *old_chain;
c5aa993b 14545
c906108c
SS
14546 save_language = current_language->la_language;
14547 save_input_radix = input_radix;
c2f4122d 14548 old_chain = save_current_space_and_thread ();
6c95b8df 14549
2a7f3dff
PA
14550 /* Note: we must not try to insert locations until after all
14551 breakpoints have been re-set. Otherwise, e.g., when re-setting
14552 breakpoint 1, we'd insert the locations of breakpoint 2, which
14553 hadn't been re-set yet, and thus may have stale locations. */
14554
35df4500 14555 ALL_BREAKPOINTS_SAFE (b, b_tmp)
c5aa993b 14556 {
4a64f543 14557 /* Format possible error msg. */
fe3f5fa8 14558 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
9ebf4acf
AC
14559 b->number);
14560 struct cleanup *cleanups = make_cleanup (xfree, message);
c5aa993b 14561 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
9ebf4acf 14562 do_cleanups (cleanups);
c5aa993b 14563 }
c906108c
SS
14564 set_language (save_language);
14565 input_radix = save_input_radix;
e62c965a 14566
0756c555 14567 jit_breakpoint_re_set ();
4efc6507 14568
6c95b8df
PA
14569 do_cleanups (old_chain);
14570
af02033e
PP
14571 create_overlay_event_breakpoint ();
14572 create_longjmp_master_breakpoint ();
14573 create_std_terminate_master_breakpoint ();
186c406b 14574 create_exception_master_breakpoint ();
2a7f3dff
PA
14575
14576 /* Now we can insert. */
14577 update_global_location_list (UGLL_MAY_INSERT);
c906108c
SS
14578}
14579\f
c906108c
SS
14580/* Reset the thread number of this breakpoint:
14581
14582 - If the breakpoint is for all threads, leave it as-is.
4a64f543 14583 - Else, reset it to the current thread for inferior_ptid. */
c906108c 14584void
fba45db2 14585breakpoint_re_set_thread (struct breakpoint *b)
c906108c
SS
14586{
14587 if (b->thread != -1)
14588 {
39f77062 14589 if (in_thread_list (inferior_ptid))
5d5658a1 14590 b->thread = ptid_to_global_thread_id (inferior_ptid);
6c95b8df
PA
14591
14592 /* We're being called after following a fork. The new fork is
14593 selected as current, and unless this was a vfork will have a
14594 different program space from the original thread. Reset that
14595 as well. */
14596 b->loc->pspace = current_program_space;
c906108c
SS
14597 }
14598}
14599
03ac34d5
MS
14600/* Set ignore-count of breakpoint number BPTNUM to COUNT.
14601 If from_tty is nonzero, it prints a message to that effect,
14602 which ends with a period (no newline). */
14603
c906108c 14604void
fba45db2 14605set_ignore_count (int bptnum, int count, int from_tty)
c906108c 14606{
52f0bd74 14607 struct breakpoint *b;
c906108c
SS
14608
14609 if (count < 0)
14610 count = 0;
14611
14612 ALL_BREAKPOINTS (b)
14613 if (b->number == bptnum)
c5aa993b 14614 {
d77f58be
SS
14615 if (is_tracepoint (b))
14616 {
14617 if (from_tty && count != 0)
14618 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14619 bptnum);
14620 return;
14621 }
14622
c5aa993b 14623 b->ignore_count = count;
221ea385
KS
14624 if (from_tty)
14625 {
14626 if (count == 0)
3e43a32a
MS
14627 printf_filtered (_("Will stop next time "
14628 "breakpoint %d is reached."),
221ea385
KS
14629 bptnum);
14630 else if (count == 1)
a3f17187 14631 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
221ea385
KS
14632 bptnum);
14633 else
3e43a32a
MS
14634 printf_filtered (_("Will ignore next %d "
14635 "crossings of breakpoint %d."),
221ea385
KS
14636 count, bptnum);
14637 }
8d3788bd 14638 observer_notify_breakpoint_modified (b);
c5aa993b
JM
14639 return;
14640 }
c906108c 14641
8a3fe4f8 14642 error (_("No breakpoint number %d."), bptnum);
c906108c
SS
14643}
14644
c906108c
SS
14645/* Command to set ignore-count of breakpoint N to COUNT. */
14646
14647static void
fba45db2 14648ignore_command (char *args, int from_tty)
c906108c
SS
14649{
14650 char *p = args;
52f0bd74 14651 int num;
c906108c
SS
14652
14653 if (p == 0)
e2e0b3e5 14654 error_no_arg (_("a breakpoint number"));
c5aa993b 14655
c906108c 14656 num = get_number (&p);
5c44784c 14657 if (num == 0)
8a3fe4f8 14658 error (_("bad breakpoint number: '%s'"), args);
c906108c 14659 if (*p == 0)
8a3fe4f8 14660 error (_("Second argument (specified ignore-count) is missing."));
c906108c
SS
14661
14662 set_ignore_count (num,
14663 longest_to_int (value_as_long (parse_and_eval (p))),
14664 from_tty);
221ea385
KS
14665 if (from_tty)
14666 printf_filtered ("\n");
c906108c
SS
14667}
14668\f
14669/* Call FUNCTION on each of the breakpoints
14670 whose numbers are given in ARGS. */
14671
14672static void
896b6bda
PA
14673map_breakpoint_numbers (const char *args,
14674 void (*function) (struct breakpoint *,
14675 void *),
95a42b64 14676 void *data)
c906108c 14677{
52f0bd74
AC
14678 int num;
14679 struct breakpoint *b, *tmp;
c906108c 14680
b9d61307 14681 if (args == 0 || *args == '\0')
e2e0b3e5 14682 error_no_arg (_("one or more breakpoint numbers"));
c906108c 14683
bfd28288 14684 number_or_range_parser parser (args);
197f0a60 14685
bfd28288 14686 while (!parser.finished ())
c906108c 14687 {
bfd28288
PA
14688 const char *p = parser.cur_tok ();
14689 bool match = false;
197f0a60 14690
bfd28288 14691 num = parser.get_number ();
5c44784c 14692 if (num == 0)
c5aa993b 14693 {
8a3fe4f8 14694 warning (_("bad breakpoint number at or near '%s'"), p);
5c44784c
JM
14695 }
14696 else
14697 {
14698 ALL_BREAKPOINTS_SAFE (b, tmp)
14699 if (b->number == num)
14700 {
bfd28288 14701 match = true;
cdac0397 14702 function (b, data);
11cf8741 14703 break;
5c44784c 14704 }
bfd28288 14705 if (!match)
a3f17187 14706 printf_unfiltered (_("No breakpoint number %d.\n"), num);
c5aa993b 14707 }
c906108c
SS
14708 }
14709}
14710
0d381245
VP
14711static struct bp_location *
14712find_location_by_number (char *number)
14713{
14714 char *dot = strchr (number, '.');
14715 char *p1;
14716 int bp_num;
14717 int loc_num;
14718 struct breakpoint *b;
14719 struct bp_location *loc;
14720
14721 *dot = '\0';
14722
14723 p1 = number;
197f0a60 14724 bp_num = get_number (&p1);
0d381245
VP
14725 if (bp_num == 0)
14726 error (_("Bad breakpoint number '%s'"), number);
14727
14728 ALL_BREAKPOINTS (b)
14729 if (b->number == bp_num)
14730 {
14731 break;
14732 }
14733
14734 if (!b || b->number != bp_num)
14735 error (_("Bad breakpoint number '%s'"), number);
14736
14737 p1 = dot+1;
197f0a60 14738 loc_num = get_number (&p1);
0d381245
VP
14739 if (loc_num == 0)
14740 error (_("Bad breakpoint location number '%s'"), number);
14741
14742 --loc_num;
14743 loc = b->loc;
14744 for (;loc_num && loc; --loc_num, loc = loc->next)
14745 ;
14746 if (!loc)
14747 error (_("Bad breakpoint location number '%s'"), dot+1);
14748
14749 return loc;
14750}
14751
14752
1900040c
MS
14753/* Set ignore-count of breakpoint number BPTNUM to COUNT.
14754 If from_tty is nonzero, it prints a message to that effect,
14755 which ends with a period (no newline). */
14756
c906108c 14757void
fba45db2 14758disable_breakpoint (struct breakpoint *bpt)
c906108c
SS
14759{
14760 /* Never disable a watchpoint scope breakpoint; we want to
14761 hit them when we leave scope so we can delete both the
14762 watchpoint and its scope breakpoint at that time. */
14763 if (bpt->type == bp_watchpoint_scope)
14764 return;
14765
b5de0fa7 14766 bpt->enable_state = bp_disabled;
c906108c 14767
b775012e
LM
14768 /* Mark breakpoint locations modified. */
14769 mark_breakpoint_modified (bpt);
14770
d248b706
KY
14771 if (target_supports_enable_disable_tracepoint ()
14772 && current_trace_status ()->running && is_tracepoint (bpt))
14773 {
14774 struct bp_location *location;
14775
14776 for (location = bpt->loc; location; location = location->next)
14777 target_disable_tracepoint (location);
14778 }
14779
44702360 14780 update_global_location_list (UGLL_DONT_INSERT);
c906108c 14781
8d3788bd 14782 observer_notify_breakpoint_modified (bpt);
c906108c
SS
14783}
14784
51be5b68
PA
14785/* A callback for iterate_over_related_breakpoints. */
14786
14787static void
14788do_disable_breakpoint (struct breakpoint *b, void *ignore)
14789{
14790 disable_breakpoint (b);
14791}
14792
95a42b64
TT
14793/* A callback for map_breakpoint_numbers that calls
14794 disable_breakpoint. */
14795
14796static void
14797do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
14798{
51be5b68 14799 iterate_over_related_breakpoints (b, do_disable_breakpoint, NULL);
95a42b64
TT
14800}
14801
c906108c 14802static void
fba45db2 14803disable_command (char *args, int from_tty)
c906108c 14804{
c906108c 14805 if (args == 0)
46c6471b
PA
14806 {
14807 struct breakpoint *bpt;
14808
14809 ALL_BREAKPOINTS (bpt)
14810 if (user_breakpoint_p (bpt))
14811 disable_breakpoint (bpt);
14812 }
9eaabc75 14813 else
0d381245 14814 {
9eaabc75
MW
14815 char *num = extract_arg (&args);
14816
14817 while (num)
d248b706 14818 {
9eaabc75 14819 if (strchr (num, '.'))
b775012e 14820 {
9eaabc75
MW
14821 struct bp_location *loc = find_location_by_number (num);
14822
14823 if (loc)
14824 {
14825 if (loc->enabled)
14826 {
14827 loc->enabled = 0;
14828 mark_breakpoint_location_modified (loc);
14829 }
14830 if (target_supports_enable_disable_tracepoint ()
14831 && current_trace_status ()->running && loc->owner
14832 && is_tracepoint (loc->owner))
14833 target_disable_tracepoint (loc);
14834 }
44702360 14835 update_global_location_list (UGLL_DONT_INSERT);
b775012e 14836 }
9eaabc75
MW
14837 else
14838 map_breakpoint_numbers (num, do_map_disable_breakpoint, NULL);
14839 num = extract_arg (&args);
d248b706 14840 }
0d381245 14841 }
c906108c
SS
14842}
14843
14844static void
816338b5
SS
14845enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14846 int count)
c906108c 14847{
afe38095 14848 int target_resources_ok;
c906108c
SS
14849
14850 if (bpt->type == bp_hardware_breakpoint)
14851 {
14852 int i;
c5aa993b 14853 i = hw_breakpoint_used_count ();
53a5351d 14854 target_resources_ok =
d92524f1 14855 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
53a5351d 14856 i + 1, 0);
c906108c 14857 if (target_resources_ok == 0)
8a3fe4f8 14858 error (_("No hardware breakpoint support in the target."));
c906108c 14859 else if (target_resources_ok < 0)
8a3fe4f8 14860 error (_("Hardware breakpoints used exceeds limit."));
c906108c
SS
14861 }
14862
cc60f2e3 14863 if (is_watchpoint (bpt))
c906108c 14864 {
d07205c2 14865 /* Initialize it just to avoid a GCC false warning. */
f486487f 14866 enum enable_state orig_enable_state = bp_disabled;
dde02812 14867
492d29ea 14868 TRY
c906108c 14869 {
3a5c3e22
PA
14870 struct watchpoint *w = (struct watchpoint *) bpt;
14871
1e718ff1
TJB
14872 orig_enable_state = bpt->enable_state;
14873 bpt->enable_state = bp_enabled;
3a5c3e22 14874 update_watchpoint (w, 1 /* reparse */);
c906108c 14875 }
492d29ea 14876 CATCH (e, RETURN_MASK_ALL)
c5aa993b 14877 {
1e718ff1 14878 bpt->enable_state = orig_enable_state;
dde02812
ES
14879 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14880 bpt->number);
14881 return;
c5aa993b 14882 }
492d29ea 14883 END_CATCH
c906108c 14884 }
0101ce28 14885
b775012e
LM
14886 bpt->enable_state = bp_enabled;
14887
14888 /* Mark breakpoint locations modified. */
14889 mark_breakpoint_modified (bpt);
14890
d248b706
KY
14891 if (target_supports_enable_disable_tracepoint ()
14892 && current_trace_status ()->running && is_tracepoint (bpt))
14893 {
14894 struct bp_location *location;
14895
14896 for (location = bpt->loc; location; location = location->next)
14897 target_enable_tracepoint (location);
14898 }
14899
b4c291bb 14900 bpt->disposition = disposition;
816338b5 14901 bpt->enable_count = count;
44702360 14902 update_global_location_list (UGLL_MAY_INSERT);
9c97429f 14903
8d3788bd 14904 observer_notify_breakpoint_modified (bpt);
c906108c
SS
14905}
14906
fe3f5fa8 14907
c906108c 14908void
fba45db2 14909enable_breakpoint (struct breakpoint *bpt)
c906108c 14910{
816338b5 14911 enable_breakpoint_disp (bpt, bpt->disposition, 0);
51be5b68
PA
14912}
14913
14914static void
14915do_enable_breakpoint (struct breakpoint *bpt, void *arg)
14916{
14917 enable_breakpoint (bpt);
c906108c
SS
14918}
14919
95a42b64
TT
14920/* A callback for map_breakpoint_numbers that calls
14921 enable_breakpoint. */
14922
14923static void
14924do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
14925{
51be5b68 14926 iterate_over_related_breakpoints (b, do_enable_breakpoint, NULL);
95a42b64
TT
14927}
14928
c906108c
SS
14929/* The enable command enables the specified breakpoints (or all defined
14930 breakpoints) so they once again become (or continue to be) effective
1272ad14 14931 in stopping the inferior. */
c906108c 14932
c906108c 14933static void
fba45db2 14934enable_command (char *args, int from_tty)
c906108c 14935{
c906108c 14936 if (args == 0)
46c6471b
PA
14937 {
14938 struct breakpoint *bpt;
14939
14940 ALL_BREAKPOINTS (bpt)
14941 if (user_breakpoint_p (bpt))
14942 enable_breakpoint (bpt);
14943 }
9eaabc75 14944 else
0d381245 14945 {
9eaabc75
MW
14946 char *num = extract_arg (&args);
14947
14948 while (num)
d248b706 14949 {
9eaabc75 14950 if (strchr (num, '.'))
b775012e 14951 {
9eaabc75
MW
14952 struct bp_location *loc = find_location_by_number (num);
14953
14954 if (loc)
14955 {
14956 if (!loc->enabled)
14957 {
14958 loc->enabled = 1;
14959 mark_breakpoint_location_modified (loc);
14960 }
14961 if (target_supports_enable_disable_tracepoint ()
14962 && current_trace_status ()->running && loc->owner
14963 && is_tracepoint (loc->owner))
14964 target_enable_tracepoint (loc);
14965 }
44702360 14966 update_global_location_list (UGLL_MAY_INSERT);
b775012e 14967 }
9eaabc75
MW
14968 else
14969 map_breakpoint_numbers (num, do_map_enable_breakpoint, NULL);
14970 num = extract_arg (&args);
d248b706 14971 }
0d381245 14972 }
c906108c
SS
14973}
14974
816338b5
SS
14975/* This struct packages up disposition data for application to multiple
14976 breakpoints. */
14977
14978struct disp_data
14979{
14980 enum bpdisp disp;
14981 int count;
14982};
14983
c906108c 14984static void
51be5b68
PA
14985do_enable_breakpoint_disp (struct breakpoint *bpt, void *arg)
14986{
816338b5 14987 struct disp_data disp_data = *(struct disp_data *) arg;
51be5b68 14988
816338b5 14989 enable_breakpoint_disp (bpt, disp_data.disp, disp_data.count);
51be5b68
PA
14990}
14991
14992static void
14993do_map_enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
c906108c 14994{
816338b5 14995 struct disp_data disp = { disp_disable, 1 };
51be5b68
PA
14996
14997 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
c906108c
SS
14998}
14999
c906108c 15000static void
fba45db2 15001enable_once_command (char *args, int from_tty)
c906108c 15002{
51be5b68 15003 map_breakpoint_numbers (args, do_map_enable_once_breakpoint, NULL);
c906108c
SS
15004}
15005
816338b5
SS
15006static void
15007do_map_enable_count_breakpoint (struct breakpoint *bpt, void *countptr)
15008{
15009 struct disp_data disp = { disp_disable, *(int *) countptr };
15010
15011 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
15012}
15013
15014static void
15015enable_count_command (char *args, int from_tty)
15016{
b9d61307
SM
15017 int count;
15018
15019 if (args == NULL)
15020 error_no_arg (_("hit count"));
15021
15022 count = get_number (&args);
816338b5
SS
15023
15024 map_breakpoint_numbers (args, do_map_enable_count_breakpoint, &count);
15025}
15026
c906108c 15027static void
51be5b68 15028do_map_enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
c906108c 15029{
816338b5 15030 struct disp_data disp = { disp_del, 1 };
51be5b68
PA
15031
15032 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
c906108c
SS
15033}
15034
c906108c 15035static void
fba45db2 15036enable_delete_command (char *args, int from_tty)
c906108c 15037{
51be5b68 15038 map_breakpoint_numbers (args, do_map_enable_delete_breakpoint, NULL);
c906108c
SS
15039}
15040\f
fa8d40ab
JJ
15041static void
15042set_breakpoint_cmd (char *args, int from_tty)
15043{
15044}
15045
15046static void
15047show_breakpoint_cmd (char *args, int from_tty)
15048{
15049}
15050
1f3b5d1b
PP
15051/* Invalidate last known value of any hardware watchpoint if
15052 the memory which that value represents has been written to by
15053 GDB itself. */
15054
15055static void
8de0566d
YQ
15056invalidate_bp_value_on_memory_change (struct inferior *inferior,
15057 CORE_ADDR addr, ssize_t len,
1f3b5d1b
PP
15058 const bfd_byte *data)
15059{
15060 struct breakpoint *bp;
15061
15062 ALL_BREAKPOINTS (bp)
15063 if (bp->enable_state == bp_enabled
3a5c3e22 15064 && bp->type == bp_hardware_watchpoint)
1f3b5d1b 15065 {
3a5c3e22 15066 struct watchpoint *wp = (struct watchpoint *) bp;
1f3b5d1b 15067
3a5c3e22
PA
15068 if (wp->val_valid && wp->val)
15069 {
15070 struct bp_location *loc;
15071
15072 for (loc = bp->loc; loc != NULL; loc = loc->next)
15073 if (loc->loc_type == bp_loc_hardware_watchpoint
15074 && loc->address + loc->length > addr
15075 && addr + len > loc->address)
15076 {
15077 value_free (wp->val);
15078 wp->val = NULL;
15079 wp->val_valid = 0;
15080 }
15081 }
1f3b5d1b
PP
15082 }
15083}
15084
8181d85f
DJ
15085/* Create and insert a breakpoint for software single step. */
15086
15087void
6c95b8df 15088insert_single_step_breakpoint (struct gdbarch *gdbarch,
4a64f543
MS
15089 struct address_space *aspace,
15090 CORE_ADDR next_pc)
8181d85f 15091{
7c16b83e
PA
15092 struct thread_info *tp = inferior_thread ();
15093 struct symtab_and_line sal;
15094 CORE_ADDR pc = next_pc;
8181d85f 15095
34b7e8a6
PA
15096 if (tp->control.single_step_breakpoints == NULL)
15097 {
15098 tp->control.single_step_breakpoints
5d5658a1 15099 = new_single_step_breakpoint (tp->global_num, gdbarch);
34b7e8a6 15100 }
8181d85f 15101
7c16b83e
PA
15102 sal = find_pc_line (pc, 0);
15103 sal.pc = pc;
15104 sal.section = find_pc_overlay (pc);
15105 sal.explicit_pc = 1;
34b7e8a6 15106 add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
8181d85f 15107
7c16b83e 15108 update_global_location_list (UGLL_INSERT);
8181d85f
DJ
15109}
15110
93f9a11f
YQ
15111/* Insert single step breakpoints according to the current state. */
15112
15113int
15114insert_single_step_breakpoints (struct gdbarch *gdbarch)
15115{
f5ea389a 15116 struct regcache *regcache = get_current_regcache ();
93f9a11f
YQ
15117 VEC (CORE_ADDR) * next_pcs;
15118
f5ea389a 15119 next_pcs = gdbarch_software_single_step (gdbarch, regcache);
93f9a11f
YQ
15120
15121 if (next_pcs != NULL)
15122 {
15123 int i;
15124 CORE_ADDR pc;
f5ea389a 15125 struct frame_info *frame = get_current_frame ();
93f9a11f
YQ
15126 struct address_space *aspace = get_frame_address_space (frame);
15127
15128 for (i = 0; VEC_iterate (CORE_ADDR, next_pcs, i, pc); i++)
15129 insert_single_step_breakpoint (gdbarch, aspace, pc);
15130
15131 VEC_free (CORE_ADDR, next_pcs);
15132
15133 return 1;
15134 }
15135 else
15136 return 0;
15137}
15138
34b7e8a6 15139/* See breakpoint.h. */
f02253f1
HZ
15140
15141int
7c16b83e
PA
15142breakpoint_has_location_inserted_here (struct breakpoint *bp,
15143 struct address_space *aspace,
15144 CORE_ADDR pc)
1aafd4da 15145{
7c16b83e 15146 struct bp_location *loc;
1aafd4da 15147
7c16b83e
PA
15148 for (loc = bp->loc; loc != NULL; loc = loc->next)
15149 if (loc->inserted
15150 && breakpoint_location_address_match (loc, aspace, pc))
15151 return 1;
1aafd4da 15152
7c16b83e 15153 return 0;
ef370185
JB
15154}
15155
15156/* Check whether a software single-step breakpoint is inserted at
15157 PC. */
15158
15159int
15160single_step_breakpoint_inserted_here_p (struct address_space *aspace,
15161 CORE_ADDR pc)
15162{
34b7e8a6
PA
15163 struct breakpoint *bpt;
15164
15165 ALL_BREAKPOINTS (bpt)
15166 {
15167 if (bpt->type == bp_single_step
15168 && breakpoint_has_location_inserted_here (bpt, aspace, pc))
15169 return 1;
15170 }
15171 return 0;
1aafd4da
UW
15172}
15173
1042e4c0
SS
15174/* Tracepoint-specific operations. */
15175
15176/* Set tracepoint count to NUM. */
15177static void
15178set_tracepoint_count (int num)
15179{
15180 tracepoint_count = num;
4fa62494 15181 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
1042e4c0
SS
15182}
15183
70221824 15184static void
1042e4c0
SS
15185trace_command (char *arg, int from_tty)
15186{
55aa24fb 15187 struct breakpoint_ops *ops;
55aa24fb 15188
ffc2605c
TT
15189 event_location_up location = string_to_event_location (&arg,
15190 current_language);
5b56227b 15191 if (location != NULL
ffc2605c 15192 && event_location_type (location.get ()) == PROBE_LOCATION)
55aa24fb
SDJ
15193 ops = &tracepoint_probe_breakpoint_ops;
15194 else
15195 ops = &tracepoint_breakpoint_ops;
15196
558a9d82 15197 create_breakpoint (get_current_arch (),
ffc2605c 15198 location.get (),
f00aae0f 15199 NULL, 0, arg, 1 /* parse arg */,
558a9d82
YQ
15200 0 /* tempflag */,
15201 bp_tracepoint /* type_wanted */,
15202 0 /* Ignore count */,
15203 pending_break_support,
15204 ops,
15205 from_tty,
15206 1 /* enabled */,
15207 0 /* internal */, 0);
1042e4c0
SS
15208}
15209
70221824 15210static void
7a697b8d
SS
15211ftrace_command (char *arg, int from_tty)
15212{
ffc2605c
TT
15213 event_location_up location = string_to_event_location (&arg,
15214 current_language);
558a9d82 15215 create_breakpoint (get_current_arch (),
ffc2605c 15216 location.get (),
f00aae0f 15217 NULL, 0, arg, 1 /* parse arg */,
558a9d82
YQ
15218 0 /* tempflag */,
15219 bp_fast_tracepoint /* type_wanted */,
15220 0 /* Ignore count */,
15221 pending_break_support,
15222 &tracepoint_breakpoint_ops,
15223 from_tty,
15224 1 /* enabled */,
15225 0 /* internal */, 0);
0fb4aa4b
PA
15226}
15227
15228/* strace command implementation. Creates a static tracepoint. */
15229
70221824 15230static void
0fb4aa4b
PA
15231strace_command (char *arg, int from_tty)
15232{
983af33b 15233 struct breakpoint_ops *ops;
ffc2605c 15234 event_location_up location;
f00aae0f 15235 struct cleanup *back_to;
983af33b
SDJ
15236
15237 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15238 or with a normal static tracepoint. */
61012eef 15239 if (arg && startswith (arg, "-m") && isspace (arg[2]))
f00aae0f
KS
15240 {
15241 ops = &strace_marker_breakpoint_ops;
15242 location = new_linespec_location (&arg);
15243 }
983af33b 15244 else
f00aae0f
KS
15245 {
15246 ops = &tracepoint_breakpoint_ops;
15247 location = string_to_event_location (&arg, current_language);
15248 }
983af33b 15249
558a9d82 15250 create_breakpoint (get_current_arch (),
ffc2605c 15251 location.get (),
f00aae0f 15252 NULL, 0, arg, 1 /* parse arg */,
558a9d82
YQ
15253 0 /* tempflag */,
15254 bp_static_tracepoint /* type_wanted */,
15255 0 /* Ignore count */,
15256 pending_break_support,
15257 ops,
15258 from_tty,
15259 1 /* enabled */,
15260 0 /* internal */, 0);
7a697b8d
SS
15261}
15262
409873ef
SS
15263/* Set up a fake reader function that gets command lines from a linked
15264 list that was acquired during tracepoint uploading. */
15265
15266static struct uploaded_tp *this_utp;
3149d8c1 15267static int next_cmd;
409873ef
SS
15268
15269static char *
15270read_uploaded_action (void)
15271{
15272 char *rslt;
15273
3149d8c1 15274 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
409873ef 15275
3149d8c1 15276 next_cmd++;
409873ef
SS
15277
15278 return rslt;
15279}
15280
00bf0b85
SS
15281/* Given information about a tracepoint as recorded on a target (which
15282 can be either a live system or a trace file), attempt to create an
15283 equivalent GDB tracepoint. This is not a reliable process, since
15284 the target does not necessarily have all the information used when
15285 the tracepoint was originally defined. */
15286
d9b3f62e 15287struct tracepoint *
00bf0b85 15288create_tracepoint_from_upload (struct uploaded_tp *utp)
d5551862 15289{
409873ef 15290 char *addr_str, small_buf[100];
d9b3f62e 15291 struct tracepoint *tp;
fd9b8c24 15292
409873ef
SS
15293 if (utp->at_string)
15294 addr_str = utp->at_string;
15295 else
15296 {
15297 /* In the absence of a source location, fall back to raw
15298 address. Since there is no way to confirm that the address
15299 means the same thing as when the trace was started, warn the
15300 user. */
3e43a32a
MS
15301 warning (_("Uploaded tracepoint %d has no "
15302 "source location, using raw address"),
409873ef 15303 utp->number);
8c042590 15304 xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
409873ef
SS
15305 addr_str = small_buf;
15306 }
15307
15308 /* There's not much we can do with a sequence of bytecodes. */
15309 if (utp->cond && !utp->cond_string)
3e43a32a
MS
15310 warning (_("Uploaded tracepoint %d condition "
15311 "has no source form, ignoring it"),
409873ef 15312 utp->number);
d5551862 15313
ffc2605c
TT
15314 event_location_up location = string_to_event_location (&addr_str,
15315 current_language);
8cdf0e15 15316 if (!create_breakpoint (get_current_arch (),
ffc2605c 15317 location.get (),
f00aae0f 15318 utp->cond_string, -1, addr_str,
e7e0cddf 15319 0 /* parse cond/thread */,
8cdf0e15 15320 0 /* tempflag */,
0fb4aa4b 15321 utp->type /* type_wanted */,
8cdf0e15
VP
15322 0 /* Ignore count */,
15323 pending_break_support,
348d480f 15324 &tracepoint_breakpoint_ops,
8cdf0e15 15325 0 /* from_tty */,
84f4c1fe 15326 utp->enabled /* enabled */,
44f238bb
PA
15327 0 /* internal */,
15328 CREATE_BREAKPOINT_FLAGS_INSERTED))
ffc2605c 15329 return NULL;
fd9b8c24 15330
409873ef 15331 /* Get the tracepoint we just created. */
fd9b8c24
PA
15332 tp = get_tracepoint (tracepoint_count);
15333 gdb_assert (tp != NULL);
d5551862 15334
00bf0b85
SS
15335 if (utp->pass > 0)
15336 {
8c042590
PM
15337 xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
15338 tp->base.number);
00bf0b85 15339
409873ef 15340 trace_pass_command (small_buf, 0);
00bf0b85
SS
15341 }
15342
409873ef
SS
15343 /* If we have uploaded versions of the original commands, set up a
15344 special-purpose "reader" function and call the usual command line
15345 reader, then pass the result to the breakpoint command-setting
15346 function. */
3149d8c1 15347 if (!VEC_empty (char_ptr, utp->cmd_strings))
00bf0b85 15348 {
93921405 15349 command_line_up cmd_list;
00bf0b85 15350
409873ef 15351 this_utp = utp;
3149d8c1 15352 next_cmd = 0;
d5551862 15353
409873ef
SS
15354 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
15355
93921405 15356 breakpoint_set_commands (&tp->base, std::move (cmd_list));
00bf0b85 15357 }
3149d8c1
SS
15358 else if (!VEC_empty (char_ptr, utp->actions)
15359 || !VEC_empty (char_ptr, utp->step_actions))
3e43a32a
MS
15360 warning (_("Uploaded tracepoint %d actions "
15361 "have no source form, ignoring them"),
409873ef 15362 utp->number);
00bf0b85 15363
f196051f
SS
15364 /* Copy any status information that might be available. */
15365 tp->base.hit_count = utp->hit_count;
15366 tp->traceframe_usage = utp->traceframe_usage;
15367
00bf0b85 15368 return tp;
d9b3f62e 15369}
00bf0b85 15370
1042e4c0
SS
15371/* Print information on tracepoint number TPNUM_EXP, or all if
15372 omitted. */
15373
15374static void
e5a67952 15375tracepoints_info (char *args, int from_tty)
1042e4c0 15376{
79a45e25 15377 struct ui_out *uiout = current_uiout;
e5a67952 15378 int num_printed;
1042e4c0 15379
e5a67952 15380 num_printed = breakpoint_1 (args, 0, is_tracepoint);
d77f58be
SS
15381
15382 if (num_printed == 0)
1042e4c0 15383 {
e5a67952 15384 if (args == NULL || *args == '\0')
112e8700 15385 uiout->message ("No tracepoints.\n");
d77f58be 15386 else
112e8700 15387 uiout->message ("No tracepoint matching '%s'.\n", args);
1042e4c0 15388 }
ad443146
SS
15389
15390 default_collect_info ();
1042e4c0
SS
15391}
15392
4a64f543 15393/* The 'enable trace' command enables tracepoints.
1042e4c0
SS
15394 Not supported by all targets. */
15395static void
15396enable_trace_command (char *args, int from_tty)
15397{
15398 enable_command (args, from_tty);
15399}
15400
4a64f543 15401/* The 'disable trace' command disables tracepoints.
1042e4c0
SS
15402 Not supported by all targets. */
15403static void
15404disable_trace_command (char *args, int from_tty)
15405{
15406 disable_command (args, from_tty);
15407}
15408
4a64f543 15409/* Remove a tracepoint (or all if no argument). */
1042e4c0
SS
15410static void
15411delete_trace_command (char *arg, int from_tty)
15412{
35df4500 15413 struct breakpoint *b, *b_tmp;
1042e4c0
SS
15414
15415 dont_repeat ();
15416
15417 if (arg == 0)
15418 {
15419 int breaks_to_delete = 0;
15420
15421 /* Delete all breakpoints if no argument.
15422 Do not delete internal or call-dummy breakpoints, these
4a64f543
MS
15423 have to be deleted with an explicit breakpoint number
15424 argument. */
1042e4c0 15425 ALL_TRACEPOINTS (b)
46c6471b 15426 if (is_tracepoint (b) && user_breakpoint_p (b))
1042e4c0
SS
15427 {
15428 breaks_to_delete = 1;
15429 break;
15430 }
1042e4c0
SS
15431
15432 /* Ask user only if there are some breakpoints to delete. */
15433 if (!from_tty
15434 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
15435 {
35df4500 15436 ALL_BREAKPOINTS_SAFE (b, b_tmp)
46c6471b 15437 if (is_tracepoint (b) && user_breakpoint_p (b))
1042e4c0 15438 delete_breakpoint (b);
1042e4c0
SS
15439 }
15440 }
15441 else
51be5b68 15442 map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
1042e4c0
SS
15443}
15444
197f0a60
TT
15445/* Helper function for trace_pass_command. */
15446
15447static void
d9b3f62e 15448trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
197f0a60 15449{
d9b3f62e 15450 tp->pass_count = count;
6f6484cd 15451 observer_notify_breakpoint_modified (&tp->base);
197f0a60
TT
15452 if (from_tty)
15453 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
d9b3f62e 15454 tp->base.number, count);
197f0a60
TT
15455}
15456
1042e4c0
SS
15457/* Set passcount for tracepoint.
15458
15459 First command argument is passcount, second is tracepoint number.
15460 If tracepoint number omitted, apply to most recently defined.
15461 Also accepts special argument "all". */
15462
15463static void
15464trace_pass_command (char *args, int from_tty)
15465{
d9b3f62e 15466 struct tracepoint *t1;
1042e4c0 15467 unsigned int count;
1042e4c0
SS
15468
15469 if (args == 0 || *args == 0)
3e43a32a
MS
15470 error (_("passcount command requires an "
15471 "argument (count + optional TP num)"));
1042e4c0 15472
4a64f543 15473 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
1042e4c0 15474
529480d0 15475 args = skip_spaces (args);
1042e4c0
SS
15476 if (*args && strncasecmp (args, "all", 3) == 0)
15477 {
d9b3f62e
PA
15478 struct breakpoint *b;
15479
1042e4c0 15480 args += 3; /* Skip special argument "all". */
1042e4c0
SS
15481 if (*args)
15482 error (_("Junk at end of arguments."));
1042e4c0 15483
d9b3f62e 15484 ALL_TRACEPOINTS (b)
197f0a60 15485 {
d9b3f62e 15486 t1 = (struct tracepoint *) b;
197f0a60
TT
15487 trace_pass_set_count (t1, count, from_tty);
15488 }
15489 }
15490 else if (*args == '\0')
1042e4c0 15491 {
5fa1d40e 15492 t1 = get_tracepoint_by_number (&args, NULL);
1042e4c0 15493 if (t1)
197f0a60
TT
15494 trace_pass_set_count (t1, count, from_tty);
15495 }
15496 else
15497 {
bfd28288
PA
15498 number_or_range_parser parser (args);
15499 while (!parser.finished ())
1042e4c0 15500 {
bfd28288 15501 t1 = get_tracepoint_by_number (&args, &parser);
197f0a60
TT
15502 if (t1)
15503 trace_pass_set_count (t1, count, from_tty);
1042e4c0
SS
15504 }
15505 }
1042e4c0
SS
15506}
15507
d9b3f62e 15508struct tracepoint *
1042e4c0
SS
15509get_tracepoint (int num)
15510{
15511 struct breakpoint *t;
15512
15513 ALL_TRACEPOINTS (t)
15514 if (t->number == num)
d9b3f62e 15515 return (struct tracepoint *) t;
1042e4c0
SS
15516
15517 return NULL;
15518}
15519
d5551862
SS
15520/* Find the tracepoint with the given target-side number (which may be
15521 different from the tracepoint number after disconnecting and
15522 reconnecting). */
15523
d9b3f62e 15524struct tracepoint *
d5551862
SS
15525get_tracepoint_by_number_on_target (int num)
15526{
d9b3f62e 15527 struct breakpoint *b;
d5551862 15528
d9b3f62e
PA
15529 ALL_TRACEPOINTS (b)
15530 {
15531 struct tracepoint *t = (struct tracepoint *) b;
15532
15533 if (t->number_on_target == num)
15534 return t;
15535 }
d5551862
SS
15536
15537 return NULL;
15538}
15539
1042e4c0 15540/* Utility: parse a tracepoint number and look it up in the list.
197f0a60 15541 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
5fa1d40e
YQ
15542 If the argument is missing, the most recent tracepoint
15543 (tracepoint_count) is returned. */
15544
d9b3f62e 15545struct tracepoint *
197f0a60 15546get_tracepoint_by_number (char **arg,
bfd28288 15547 number_or_range_parser *parser)
1042e4c0 15548{
1042e4c0
SS
15549 struct breakpoint *t;
15550 int tpnum;
15551 char *instring = arg == NULL ? NULL : *arg;
15552
bfd28288 15553 if (parser != NULL)
197f0a60 15554 {
bfd28288
PA
15555 gdb_assert (!parser->finished ());
15556 tpnum = parser->get_number ();
197f0a60
TT
15557 }
15558 else if (arg == NULL || *arg == NULL || ! **arg)
5fa1d40e 15559 tpnum = tracepoint_count;
1042e4c0 15560 else
197f0a60 15561 tpnum = get_number (arg);
1042e4c0
SS
15562
15563 if (tpnum <= 0)
15564 {
15565 if (instring && *instring)
15566 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15567 instring);
15568 else
5fa1d40e 15569 printf_filtered (_("No previous tracepoint\n"));
1042e4c0
SS
15570 return NULL;
15571 }
15572
15573 ALL_TRACEPOINTS (t)
15574 if (t->number == tpnum)
15575 {
d9b3f62e 15576 return (struct tracepoint *) t;
1042e4c0
SS
15577 }
15578
1042e4c0
SS
15579 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15580 return NULL;
15581}
15582
d9b3f62e
PA
15583void
15584print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15585{
15586 if (b->thread != -1)
15587 fprintf_unfiltered (fp, " thread %d", b->thread);
15588
15589 if (b->task != 0)
15590 fprintf_unfiltered (fp, " task %d", b->task);
15591
15592 fprintf_unfiltered (fp, "\n");
15593}
15594
6149aea9
PA
15595/* Save information on user settable breakpoints (watchpoints, etc) to
15596 a new script file named FILENAME. If FILTER is non-NULL, call it
15597 on each breakpoint and only include the ones for which it returns
15598 non-zero. */
15599
1042e4c0 15600static void
6149aea9
PA
15601save_breakpoints (char *filename, int from_tty,
15602 int (*filter) (const struct breakpoint *))
1042e4c0
SS
15603{
15604 struct breakpoint *tp;
6149aea9 15605 int any = 0;
1042e4c0 15606 struct cleanup *cleanup;
6149aea9 15607 int extra_trace_bits = 0;
1042e4c0 15608
6149aea9
PA
15609 if (filename == 0 || *filename == 0)
15610 error (_("Argument required (file name in which to save)"));
1042e4c0
SS
15611
15612 /* See if we have anything to save. */
6149aea9 15613 ALL_BREAKPOINTS (tp)
1042e4c0 15614 {
6149aea9 15615 /* Skip internal and momentary breakpoints. */
09d682a4 15616 if (!user_breakpoint_p (tp))
6149aea9
PA
15617 continue;
15618
15619 /* If we have a filter, only save the breakpoints it accepts. */
15620 if (filter && !filter (tp))
15621 continue;
15622
15623 any = 1;
15624
15625 if (is_tracepoint (tp))
15626 {
15627 extra_trace_bits = 1;
15628
15629 /* We can stop searching. */
15630 break;
15631 }
1042e4c0 15632 }
6149aea9
PA
15633
15634 if (!any)
1042e4c0 15635 {
6149aea9 15636 warning (_("Nothing to save."));
1042e4c0
SS
15637 return;
15638 }
15639
c718be47
PA
15640 filename = tilde_expand (filename);
15641 cleanup = make_cleanup (xfree, filename);
d7e74731
PA
15642
15643 stdio_file fp;
15644
15645 if (!fp.open (filename, "w"))
6149aea9
PA
15646 error (_("Unable to open file '%s' for saving (%s)"),
15647 filename, safe_strerror (errno));
8bf6485c 15648
6149aea9 15649 if (extra_trace_bits)
d7e74731 15650 save_trace_state_variables (&fp);
8bf6485c 15651
6149aea9 15652 ALL_BREAKPOINTS (tp)
1042e4c0 15653 {
6149aea9 15654 /* Skip internal and momentary breakpoints. */
09d682a4 15655 if (!user_breakpoint_p (tp))
6149aea9 15656 continue;
8bf6485c 15657
6149aea9
PA
15658 /* If we have a filter, only save the breakpoints it accepts. */
15659 if (filter && !filter (tp))
15660 continue;
15661
d7e74731 15662 tp->ops->print_recreate (tp, &fp);
1042e4c0 15663
6149aea9
PA
15664 /* Note, we can't rely on tp->number for anything, as we can't
15665 assume the recreated breakpoint numbers will match. Use $bpnum
15666 instead. */
15667
15668 if (tp->cond_string)
d7e74731 15669 fp.printf (" condition $bpnum %s\n", tp->cond_string);
6149aea9
PA
15670
15671 if (tp->ignore_count)
d7e74731 15672 fp.printf (" ignore $bpnum %d\n", tp->ignore_count);
6149aea9 15673
2d9442cc 15674 if (tp->type != bp_dprintf && tp->commands)
1042e4c0 15675 {
d7e74731 15676 fp.puts (" commands\n");
a7bdde9e 15677
d7e74731 15678 current_uiout->redirect (&fp);
492d29ea 15679 TRY
1042e4c0 15680 {
79a45e25 15681 print_command_lines (current_uiout, tp->commands->commands, 2);
a7bdde9e 15682 }
492d29ea
PA
15683 CATCH (ex, RETURN_MASK_ALL)
15684 {
112e8700 15685 current_uiout->redirect (NULL);
492d29ea
PA
15686 throw_exception (ex);
15687 }
15688 END_CATCH
1042e4c0 15689
112e8700 15690 current_uiout->redirect (NULL);
d7e74731 15691 fp.puts (" end\n");
1042e4c0 15692 }
6149aea9
PA
15693
15694 if (tp->enable_state == bp_disabled)
d7e74731 15695 fp.puts ("disable $bpnum\n");
6149aea9
PA
15696
15697 /* If this is a multi-location breakpoint, check if the locations
15698 should be individually disabled. Watchpoint locations are
15699 special, and not user visible. */
15700 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15701 {
15702 struct bp_location *loc;
15703 int n = 1;
15704
15705 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15706 if (!loc->enabled)
d7e74731 15707 fp.printf ("disable $bpnum.%d\n", n);
6149aea9 15708 }
1042e4c0 15709 }
8bf6485c 15710
6149aea9 15711 if (extra_trace_bits && *default_collect)
d7e74731 15712 fp.printf ("set default-collect %s\n", default_collect);
8bf6485c 15713
1042e4c0 15714 if (from_tty)
6149aea9 15715 printf_filtered (_("Saved to file '%s'.\n"), filename);
c718be47 15716 do_cleanups (cleanup);
6149aea9
PA
15717}
15718
15719/* The `save breakpoints' command. */
15720
15721static void
15722save_breakpoints_command (char *args, int from_tty)
15723{
15724 save_breakpoints (args, from_tty, NULL);
15725}
15726
15727/* The `save tracepoints' command. */
15728
15729static void
15730save_tracepoints_command (char *args, int from_tty)
15731{
15732 save_breakpoints (args, from_tty, is_tracepoint);
1042e4c0
SS
15733}
15734
15735/* Create a vector of all tracepoints. */
15736
15737VEC(breakpoint_p) *
eeae04df 15738all_tracepoints (void)
1042e4c0
SS
15739{
15740 VEC(breakpoint_p) *tp_vec = 0;
15741 struct breakpoint *tp;
15742
15743 ALL_TRACEPOINTS (tp)
15744 {
15745 VEC_safe_push (breakpoint_p, tp_vec, tp);
15746 }
15747
15748 return tp_vec;
15749}
15750
c906108c 15751\f
629500fa
KS
15752/* This help string is used to consolidate all the help string for specifying
15753 locations used by several commands. */
15754
15755#define LOCATION_HELP_STRING \
15756"Linespecs are colon-separated lists of location parameters, such as\n\
15757source filename, function name, label name, and line number.\n\
15758Example: To specify the start of a label named \"the_top\" in the\n\
15759function \"fact\" in the file \"factorial.c\", use\n\
15760\"factorial.c:fact:the_top\".\n\
15761\n\
15762Address locations begin with \"*\" and specify an exact address in the\n\
15763program. Example: To specify the fourth byte past the start function\n\
15764\"main\", use \"*main + 4\".\n\
15765\n\
15766Explicit locations are similar to linespecs but use an option/argument\n\
15767syntax to specify location parameters.\n\
15768Example: To specify the start of the label named \"the_top\" in the\n\
15769function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15770-function fact -label the_top\".\n"
15771
4a64f543
MS
15772/* This help string is used for the break, hbreak, tbreak and thbreak
15773 commands. It is defined as a macro to prevent duplication.
15774 COMMAND should be a string constant containing the name of the
15775 command. */
629500fa 15776
31e2b00f 15777#define BREAK_ARGS_HELP(command) \
fb7b5af4
SDJ
15778command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15779PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15780probe point. Accepted values are `-probe' (for a generic, automatically\n\
d4777acb
JM
15781guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15782`-probe-dtrace' (for a DTrace probe).\n\
629500fa
KS
15783LOCATION may be a linespec, address, or explicit location as described\n\
15784below.\n\
15785\n\
dc10affe
PA
15786With no LOCATION, uses current execution address of the selected\n\
15787stack frame. This is useful for breaking on return to a stack frame.\n\
31e2b00f
AS
15788\n\
15789THREADNUM is the number from \"info threads\".\n\
15790CONDITION is a boolean expression.\n\
629500fa 15791\n" LOCATION_HELP_STRING "\n\
d41c0fc8
PA
15792Multiple breakpoints at one place are permitted, and useful if their\n\
15793conditions are different.\n\
31e2b00f
AS
15794\n\
15795Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15796
44feb3ce
TT
15797/* List of subcommands for "catch". */
15798static struct cmd_list_element *catch_cmdlist;
15799
15800/* List of subcommands for "tcatch". */
15801static struct cmd_list_element *tcatch_cmdlist;
15802
9ac4176b 15803void
a121b7c1 15804add_catch_command (const char *name, const char *docstring,
82ae6c8d 15805 cmd_sfunc_ftype *sfunc,
625e8578 15806 completer_ftype *completer,
44feb3ce
TT
15807 void *user_data_catch,
15808 void *user_data_tcatch)
15809{
15810 struct cmd_list_element *command;
15811
15812 command = add_cmd (name, class_breakpoint, NULL, docstring,
15813 &catch_cmdlist);
15814 set_cmd_sfunc (command, sfunc);
15815 set_cmd_context (command, user_data_catch);
a96d9b2e 15816 set_cmd_completer (command, completer);
44feb3ce
TT
15817
15818 command = add_cmd (name, class_breakpoint, NULL, docstring,
15819 &tcatch_cmdlist);
15820 set_cmd_sfunc (command, sfunc);
15821 set_cmd_context (command, user_data_tcatch);
a96d9b2e 15822 set_cmd_completer (command, completer);
44feb3ce
TT
15823}
15824
6149aea9
PA
15825static void
15826save_command (char *arg, int from_tty)
15827{
3e43a32a
MS
15828 printf_unfiltered (_("\"save\" must be followed by "
15829 "the name of a save subcommand.\n"));
635c7e8a 15830 help_list (save_cmdlist, "save ", all_commands, gdb_stdout);
6149aea9
PA
15831}
15832
84f4c1fe
PM
15833struct breakpoint *
15834iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15835 void *data)
15836{
35df4500 15837 struct breakpoint *b, *b_tmp;
84f4c1fe 15838
35df4500 15839 ALL_BREAKPOINTS_SAFE (b, b_tmp)
84f4c1fe
PM
15840 {
15841 if ((*callback) (b, data))
15842 return b;
15843 }
15844
15845 return NULL;
15846}
15847
0574c78f
GB
15848/* Zero if any of the breakpoint's locations could be a location where
15849 functions have been inlined, nonzero otherwise. */
15850
15851static int
15852is_non_inline_function (struct breakpoint *b)
15853{
15854 /* The shared library event breakpoint is set on the address of a
15855 non-inline function. */
15856 if (b->type == bp_shlib_event)
15857 return 1;
15858
15859 return 0;
15860}
15861
15862/* Nonzero if the specified PC cannot be a location where functions
15863 have been inlined. */
15864
15865int
09ac7c10
TT
15866pc_at_non_inline_function (struct address_space *aspace, CORE_ADDR pc,
15867 const struct target_waitstatus *ws)
0574c78f
GB
15868{
15869 struct breakpoint *b;
15870 struct bp_location *bl;
15871
15872 ALL_BREAKPOINTS (b)
15873 {
15874 if (!is_non_inline_function (b))
15875 continue;
15876
15877 for (bl = b->loc; bl != NULL; bl = bl->next)
15878 {
15879 if (!bl->shlib_disabled
09ac7c10 15880 && bpstat_check_location (bl, aspace, pc, ws))
0574c78f
GB
15881 return 1;
15882 }
15883 }
15884
15885 return 0;
15886}
15887
2f202fde
JK
15888/* Remove any references to OBJFILE which is going to be freed. */
15889
15890void
15891breakpoint_free_objfile (struct objfile *objfile)
15892{
15893 struct bp_location **locp, *loc;
15894
15895 ALL_BP_LOCATIONS (loc, locp)
eb822aa6 15896 if (loc->symtab != NULL && SYMTAB_OBJFILE (loc->symtab) == objfile)
2f202fde
JK
15897 loc->symtab = NULL;
15898}
15899
2060206e
PA
15900void
15901initialize_breakpoint_ops (void)
15902{
15903 static int initialized = 0;
15904
15905 struct breakpoint_ops *ops;
15906
15907 if (initialized)
15908 return;
15909 initialized = 1;
15910
15911 /* The breakpoint_ops structure to be inherit by all kinds of
15912 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15913 internal and momentary breakpoints, etc.). */
15914 ops = &bkpt_base_breakpoint_ops;
15915 *ops = base_breakpoint_ops;
15916 ops->re_set = bkpt_re_set;
15917 ops->insert_location = bkpt_insert_location;
15918 ops->remove_location = bkpt_remove_location;
15919 ops->breakpoint_hit = bkpt_breakpoint_hit;
5f700d83 15920 ops->create_sals_from_location = bkpt_create_sals_from_location;
983af33b 15921 ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
5f700d83 15922 ops->decode_location = bkpt_decode_location;
2060206e
PA
15923
15924 /* The breakpoint_ops structure to be used in regular breakpoints. */
15925 ops = &bkpt_breakpoint_ops;
15926 *ops = bkpt_base_breakpoint_ops;
15927 ops->re_set = bkpt_re_set;
15928 ops->resources_needed = bkpt_resources_needed;
15929 ops->print_it = bkpt_print_it;
15930 ops->print_mention = bkpt_print_mention;
15931 ops->print_recreate = bkpt_print_recreate;
15932
15933 /* Ranged breakpoints. */
15934 ops = &ranged_breakpoint_ops;
15935 *ops = bkpt_breakpoint_ops;
15936 ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15937 ops->resources_needed = resources_needed_ranged_breakpoint;
15938 ops->print_it = print_it_ranged_breakpoint;
15939 ops->print_one = print_one_ranged_breakpoint;
15940 ops->print_one_detail = print_one_detail_ranged_breakpoint;
15941 ops->print_mention = print_mention_ranged_breakpoint;
15942 ops->print_recreate = print_recreate_ranged_breakpoint;
15943
15944 /* Internal breakpoints. */
15945 ops = &internal_breakpoint_ops;
15946 *ops = bkpt_base_breakpoint_ops;
15947 ops->re_set = internal_bkpt_re_set;
15948 ops->check_status = internal_bkpt_check_status;
15949 ops->print_it = internal_bkpt_print_it;
15950 ops->print_mention = internal_bkpt_print_mention;
15951
15952 /* Momentary breakpoints. */
15953 ops = &momentary_breakpoint_ops;
15954 *ops = bkpt_base_breakpoint_ops;
15955 ops->re_set = momentary_bkpt_re_set;
15956 ops->check_status = momentary_bkpt_check_status;
15957 ops->print_it = momentary_bkpt_print_it;
15958 ops->print_mention = momentary_bkpt_print_mention;
15959
e2e4d78b
JK
15960 /* Momentary breakpoints for bp_longjmp and bp_exception. */
15961 ops = &longjmp_breakpoint_ops;
15962 *ops = momentary_breakpoint_ops;
15963 ops->dtor = longjmp_bkpt_dtor;
15964
55aa24fb
SDJ
15965 /* Probe breakpoints. */
15966 ops = &bkpt_probe_breakpoint_ops;
15967 *ops = bkpt_breakpoint_ops;
15968 ops->insert_location = bkpt_probe_insert_location;
15969 ops->remove_location = bkpt_probe_remove_location;
5f700d83
KS
15970 ops->create_sals_from_location = bkpt_probe_create_sals_from_location;
15971 ops->decode_location = bkpt_probe_decode_location;
55aa24fb 15972
2060206e
PA
15973 /* Watchpoints. */
15974 ops = &watchpoint_breakpoint_ops;
15975 *ops = base_breakpoint_ops;
3a5c3e22 15976 ops->dtor = dtor_watchpoint;
2060206e
PA
15977 ops->re_set = re_set_watchpoint;
15978 ops->insert_location = insert_watchpoint;
15979 ops->remove_location = remove_watchpoint;
15980 ops->breakpoint_hit = breakpoint_hit_watchpoint;
15981 ops->check_status = check_status_watchpoint;
15982 ops->resources_needed = resources_needed_watchpoint;
15983 ops->works_in_software_mode = works_in_software_mode_watchpoint;
15984 ops->print_it = print_it_watchpoint;
15985 ops->print_mention = print_mention_watchpoint;
15986 ops->print_recreate = print_recreate_watchpoint;
427cd150 15987 ops->explains_signal = explains_signal_watchpoint;
2060206e
PA
15988
15989 /* Masked watchpoints. */
15990 ops = &masked_watchpoint_breakpoint_ops;
15991 *ops = watchpoint_breakpoint_ops;
15992 ops->insert_location = insert_masked_watchpoint;
15993 ops->remove_location = remove_masked_watchpoint;
15994 ops->resources_needed = resources_needed_masked_watchpoint;
15995 ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15996 ops->print_it = print_it_masked_watchpoint;
15997 ops->print_one_detail = print_one_detail_masked_watchpoint;
15998 ops->print_mention = print_mention_masked_watchpoint;
15999 ops->print_recreate = print_recreate_masked_watchpoint;
16000
16001 /* Tracepoints. */
16002 ops = &tracepoint_breakpoint_ops;
16003 *ops = base_breakpoint_ops;
16004 ops->re_set = tracepoint_re_set;
16005 ops->breakpoint_hit = tracepoint_breakpoint_hit;
16006 ops->print_one_detail = tracepoint_print_one_detail;
16007 ops->print_mention = tracepoint_print_mention;
16008 ops->print_recreate = tracepoint_print_recreate;
5f700d83 16009 ops->create_sals_from_location = tracepoint_create_sals_from_location;
983af33b 16010 ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
5f700d83 16011 ops->decode_location = tracepoint_decode_location;
983af33b 16012
55aa24fb
SDJ
16013 /* Probe tracepoints. */
16014 ops = &tracepoint_probe_breakpoint_ops;
16015 *ops = tracepoint_breakpoint_ops;
5f700d83
KS
16016 ops->create_sals_from_location = tracepoint_probe_create_sals_from_location;
16017 ops->decode_location = tracepoint_probe_decode_location;
55aa24fb 16018
983af33b
SDJ
16019 /* Static tracepoints with marker (`-m'). */
16020 ops = &strace_marker_breakpoint_ops;
16021 *ops = tracepoint_breakpoint_ops;
5f700d83 16022 ops->create_sals_from_location = strace_marker_create_sals_from_location;
983af33b 16023 ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
5f700d83 16024 ops->decode_location = strace_marker_decode_location;
2060206e
PA
16025
16026 /* Fork catchpoints. */
16027 ops = &catch_fork_breakpoint_ops;
16028 *ops = base_breakpoint_ops;
16029 ops->insert_location = insert_catch_fork;
16030 ops->remove_location = remove_catch_fork;
16031 ops->breakpoint_hit = breakpoint_hit_catch_fork;
16032 ops->print_it = print_it_catch_fork;
16033 ops->print_one = print_one_catch_fork;
16034 ops->print_mention = print_mention_catch_fork;
16035 ops->print_recreate = print_recreate_catch_fork;
16036
16037 /* Vfork catchpoints. */
16038 ops = &catch_vfork_breakpoint_ops;
16039 *ops = base_breakpoint_ops;
16040 ops->insert_location = insert_catch_vfork;
16041 ops->remove_location = remove_catch_vfork;
16042 ops->breakpoint_hit = breakpoint_hit_catch_vfork;
16043 ops->print_it = print_it_catch_vfork;
16044 ops->print_one = print_one_catch_vfork;
16045 ops->print_mention = print_mention_catch_vfork;
16046 ops->print_recreate = print_recreate_catch_vfork;
16047
16048 /* Exec catchpoints. */
16049 ops = &catch_exec_breakpoint_ops;
16050 *ops = base_breakpoint_ops;
16051 ops->dtor = dtor_catch_exec;
16052 ops->insert_location = insert_catch_exec;
16053 ops->remove_location = remove_catch_exec;
16054 ops->breakpoint_hit = breakpoint_hit_catch_exec;
16055 ops->print_it = print_it_catch_exec;
16056 ops->print_one = print_one_catch_exec;
16057 ops->print_mention = print_mention_catch_exec;
16058 ops->print_recreate = print_recreate_catch_exec;
16059
edcc5120
TT
16060 /* Solib-related catchpoints. */
16061 ops = &catch_solib_breakpoint_ops;
16062 *ops = base_breakpoint_ops;
16063 ops->dtor = dtor_catch_solib;
16064 ops->insert_location = insert_catch_solib;
16065 ops->remove_location = remove_catch_solib;
16066 ops->breakpoint_hit = breakpoint_hit_catch_solib;
16067 ops->check_status = check_status_catch_solib;
16068 ops->print_it = print_it_catch_solib;
16069 ops->print_one = print_one_catch_solib;
16070 ops->print_mention = print_mention_catch_solib;
16071 ops->print_recreate = print_recreate_catch_solib;
e7e0cddf
SS
16072
16073 ops = &dprintf_breakpoint_ops;
16074 *ops = bkpt_base_breakpoint_ops;
5c2b4418 16075 ops->re_set = dprintf_re_set;
e7e0cddf
SS
16076 ops->resources_needed = bkpt_resources_needed;
16077 ops->print_it = bkpt_print_it;
16078 ops->print_mention = bkpt_print_mention;
2d9442cc 16079 ops->print_recreate = dprintf_print_recreate;
9d6e6e84 16080 ops->after_condition_true = dprintf_after_condition_true;
cd1608cc 16081 ops->breakpoint_hit = dprintf_breakpoint_hit;
2060206e
PA
16082}
16083
8bfd80db
YQ
16084/* Chain containing all defined "enable breakpoint" subcommands. */
16085
16086static struct cmd_list_element *enablebreaklist = NULL;
16087
c906108c 16088void
fba45db2 16089_initialize_breakpoint (void)
c906108c
SS
16090{
16091 struct cmd_list_element *c;
16092
2060206e
PA
16093 initialize_breakpoint_ops ();
16094
84acb35a 16095 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
63644780 16096 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile);
1f3b5d1b 16097 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
84acb35a 16098
55aa24fb
SDJ
16099 breakpoint_objfile_key
16100 = register_objfile_data_with_cleanup (NULL, free_breakpoint_probes);
17450429 16101
c906108c
SS
16102 breakpoint_chain = 0;
16103 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
16104 before a breakpoint is set. */
16105 breakpoint_count = 0;
16106
1042e4c0
SS
16107 tracepoint_count = 0;
16108
1bedd215
AC
16109 add_com ("ignore", class_breakpoint, ignore_command, _("\
16110Set ignore-count of breakpoint number N to COUNT.\n\
16111Usage is `ignore N COUNT'."));
c906108c 16112
1bedd215 16113 add_com ("commands", class_breakpoint, commands_command, _("\
18da0c51
MG
16114Set commands to be executed when the given breakpoints are hit.\n\
16115Give a space-separated breakpoint list as argument after \"commands\".\n\
16116A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
16117(e.g. `5-7').\n\
c906108c
SS
16118With no argument, the targeted breakpoint is the last one set.\n\
16119The commands themselves follow starting on the next line.\n\
16120Type a line containing \"end\" to indicate the end of them.\n\
16121Give \"silent\" as the first line to make the breakpoint silent;\n\
1bedd215 16122then no output is printed when it is hit, except what the commands print."));
c906108c 16123
d55637df 16124 c = add_com ("condition", class_breakpoint, condition_command, _("\
1bedd215 16125Specify breakpoint number N to break only if COND is true.\n\
c906108c 16126Usage is `condition N COND', where N is an integer and COND is an\n\
1bedd215 16127expression to be evaluated whenever breakpoint N is reached."));
d55637df 16128 set_cmd_completer (c, condition_completer);
c906108c 16129
1bedd215 16130 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
31e2b00f 16131Set a temporary breakpoint.\n\
c906108c
SS
16132Like \"break\" except the breakpoint is only temporary,\n\
16133so it will be deleted when hit. Equivalent to \"break\" followed\n\
31e2b00f
AS
16134by using \"enable delete\" on the breakpoint number.\n\
16135\n"
16136BREAK_ARGS_HELP ("tbreak")));
5ba2abeb 16137 set_cmd_completer (c, location_completer);
c94fdfd0 16138
1bedd215 16139 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
a3be7890 16140Set a hardware assisted breakpoint.\n\
c906108c 16141Like \"break\" except the breakpoint requires hardware support,\n\
31e2b00f
AS
16142some target hardware may not have this support.\n\
16143\n"
16144BREAK_ARGS_HELP ("hbreak")));
5ba2abeb 16145 set_cmd_completer (c, location_completer);
c906108c 16146
1bedd215 16147 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
31e2b00f 16148Set a temporary hardware assisted breakpoint.\n\
c906108c 16149Like \"hbreak\" except the breakpoint is only temporary,\n\
31e2b00f
AS
16150so it will be deleted when hit.\n\
16151\n"
16152BREAK_ARGS_HELP ("thbreak")));
5ba2abeb 16153 set_cmd_completer (c, location_completer);
c906108c 16154
1bedd215
AC
16155 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
16156Enable some breakpoints.\n\
c906108c
SS
16157Give breakpoint numbers (separated by spaces) as arguments.\n\
16158With no subcommand, breakpoints are enabled until you command otherwise.\n\
16159This is used to cancel the effect of the \"disable\" command.\n\
1bedd215 16160With a subcommand you can enable temporarily."),
c906108c 16161 &enablelist, "enable ", 1, &cmdlist);
c906108c
SS
16162
16163 add_com_alias ("en", "enable", class_breakpoint, 1);
16164
84951ab5 16165 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
1bedd215 16166Enable some breakpoints.\n\
c906108c
SS
16167Give breakpoint numbers (separated by spaces) as arguments.\n\
16168This is used to cancel the effect of the \"disable\" command.\n\
1bedd215 16169May be abbreviated to simply \"enable\".\n"),
c5aa993b 16170 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
c906108c 16171
1a966eab
AC
16172 add_cmd ("once", no_class, enable_once_command, _("\
16173Enable breakpoints for one hit. Give breakpoint numbers.\n\
16174If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
c906108c
SS
16175 &enablebreaklist);
16176
1a966eab
AC
16177 add_cmd ("delete", no_class, enable_delete_command, _("\
16178Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16179If a breakpoint is hit while enabled in this fashion, it is deleted."),
c906108c
SS
16180 &enablebreaklist);
16181
816338b5
SS
16182 add_cmd ("count", no_class, enable_count_command, _("\
16183Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16184If a breakpoint is hit while enabled in this fashion,\n\
16185the count is decremented; when it reaches zero, the breakpoint is disabled."),
16186 &enablebreaklist);
16187
1a966eab
AC
16188 add_cmd ("delete", no_class, enable_delete_command, _("\
16189Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16190If a breakpoint is hit while enabled in this fashion, it is deleted."),
c906108c
SS
16191 &enablelist);
16192
1a966eab
AC
16193 add_cmd ("once", no_class, enable_once_command, _("\
16194Enable breakpoints for one hit. Give breakpoint numbers.\n\
16195If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
816338b5
SS
16196 &enablelist);
16197
16198 add_cmd ("count", no_class, enable_count_command, _("\
16199Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16200If a breakpoint is hit while enabled in this fashion,\n\
16201the count is decremented; when it reaches zero, the breakpoint is disabled."),
c906108c
SS
16202 &enablelist);
16203
1bedd215
AC
16204 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
16205Disable some breakpoints.\n\
c906108c
SS
16206Arguments are breakpoint numbers with spaces in between.\n\
16207To disable all breakpoints, give no argument.\n\
64b9b334 16208A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
c906108c
SS
16209 &disablelist, "disable ", 1, &cmdlist);
16210 add_com_alias ("dis", "disable", class_breakpoint, 1);
16211 add_com_alias ("disa", "disable", class_breakpoint, 1);
c906108c 16212
1a966eab
AC
16213 add_cmd ("breakpoints", class_alias, disable_command, _("\
16214Disable some breakpoints.\n\
c906108c
SS
16215Arguments are breakpoint numbers with spaces in between.\n\
16216To disable all breakpoints, give no argument.\n\
64b9b334 16217A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
1a966eab 16218This command may be abbreviated \"disable\"."),
c906108c
SS
16219 &disablelist);
16220
1bedd215
AC
16221 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
16222Delete some breakpoints or auto-display expressions.\n\
c906108c
SS
16223Arguments are breakpoint numbers with spaces in between.\n\
16224To delete all breakpoints, give no argument.\n\
16225\n\
16226Also a prefix command for deletion of other GDB objects.\n\
1bedd215 16227The \"unset\" command is also an alias for \"delete\"."),
c906108c
SS
16228 &deletelist, "delete ", 1, &cmdlist);
16229 add_com_alias ("d", "delete", class_breakpoint, 1);
7f198e01 16230 add_com_alias ("del", "delete", class_breakpoint, 1);
c906108c 16231
1a966eab
AC
16232 add_cmd ("breakpoints", class_alias, delete_command, _("\
16233Delete some breakpoints or auto-display expressions.\n\
c906108c
SS
16234Arguments are breakpoint numbers with spaces in between.\n\
16235To delete all breakpoints, give no argument.\n\
1a966eab 16236This command may be abbreviated \"delete\"."),
c906108c
SS
16237 &deletelist);
16238
1bedd215 16239 add_com ("clear", class_breakpoint, clear_command, _("\
629500fa
KS
16240Clear breakpoint at specified location.\n\
16241Argument may be a linespec, explicit, or address location as described below.\n\
1bedd215
AC
16242\n\
16243With no argument, clears all breakpoints in the line that the selected frame\n\
629500fa
KS
16244is executing in.\n"
16245"\n" LOCATION_HELP_STRING "\n\
1bedd215 16246See also the \"delete\" command which clears breakpoints by number."));
a6cc4789 16247 add_com_alias ("cl", "clear", class_breakpoint, 1);
c906108c 16248
1bedd215 16249 c = add_com ("break", class_breakpoint, break_command, _("\
629500fa 16250Set breakpoint at specified location.\n"
31e2b00f 16251BREAK_ARGS_HELP ("break")));
5ba2abeb 16252 set_cmd_completer (c, location_completer);
c94fdfd0 16253
c906108c
SS
16254 add_com_alias ("b", "break", class_run, 1);
16255 add_com_alias ("br", "break", class_run, 1);
16256 add_com_alias ("bre", "break", class_run, 1);
16257 add_com_alias ("brea", "break", class_run, 1);
16258
c906108c
SS
16259 if (dbx_commands)
16260 {
1bedd215
AC
16261 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
16262Break in function/address or break at a line in the current file."),
c5aa993b
JM
16263 &stoplist, "stop ", 1, &cmdlist);
16264 add_cmd ("in", class_breakpoint, stopin_command,
1a966eab 16265 _("Break in function or address."), &stoplist);
c5aa993b 16266 add_cmd ("at", class_breakpoint, stopat_command,
1a966eab 16267 _("Break at a line in the current file."), &stoplist);
1bedd215
AC
16268 add_com ("status", class_info, breakpoints_info, _("\
16269Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
c906108c
SS
16270The \"Type\" column indicates one of:\n\
16271\tbreakpoint - normal breakpoint\n\
16272\twatchpoint - watchpoint\n\
16273The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16274the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16275breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
1bedd215
AC
16276address and file/line number respectively.\n\
16277\n\
16278Convenience variable \"$_\" and default examine address for \"x\"\n\
d1aa2f50
NR
16279are set to the address of the last breakpoint listed unless the command\n\
16280is prefixed with \"server \".\n\n\
c906108c 16281Convenience variable \"$bpnum\" contains the number of the last\n\
1bedd215 16282breakpoint set."));
c906108c
SS
16283 }
16284
1bedd215 16285 add_info ("breakpoints", breakpoints_info, _("\
e5a67952 16286Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
c906108c
SS
16287The \"Type\" column indicates one of:\n\
16288\tbreakpoint - normal breakpoint\n\
16289\twatchpoint - watchpoint\n\
16290The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16291the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16292breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
1bedd215
AC
16293address and file/line number respectively.\n\
16294\n\
16295Convenience variable \"$_\" and default examine address for \"x\"\n\
d1aa2f50
NR
16296are set to the address of the last breakpoint listed unless the command\n\
16297is prefixed with \"server \".\n\n\
c906108c 16298Convenience variable \"$bpnum\" contains the number of the last\n\
1bedd215 16299breakpoint set."));
c906108c 16300
6b04bdb7
MS
16301 add_info_alias ("b", "breakpoints", 1);
16302
1a966eab
AC
16303 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
16304Status of all breakpoints, or breakpoint number NUMBER.\n\
c906108c
SS
16305The \"Type\" column indicates one of:\n\
16306\tbreakpoint - normal breakpoint\n\
16307\twatchpoint - watchpoint\n\
16308\tlongjmp - internal breakpoint used to step through longjmp()\n\
16309\tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16310\tuntil - internal breakpoint used by the \"until\" command\n\
1a966eab
AC
16311\tfinish - internal breakpoint used by the \"finish\" command\n\
16312The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
c906108c
SS
16313the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16314breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
1a966eab
AC
16315address and file/line number respectively.\n\
16316\n\
16317Convenience variable \"$_\" and default examine address for \"x\"\n\
d1aa2f50
NR
16318are set to the address of the last breakpoint listed unless the command\n\
16319is prefixed with \"server \".\n\n\
c906108c 16320Convenience variable \"$bpnum\" contains the number of the last\n\
1a966eab 16321breakpoint set."),
c906108c
SS
16322 &maintenanceinfolist);
16323
44feb3ce
TT
16324 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
16325Set catchpoints to catch events."),
16326 &catch_cmdlist, "catch ",
16327 0/*allow-unknown*/, &cmdlist);
16328
16329 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
16330Set temporary catchpoints to catch events."),
16331 &tcatch_cmdlist, "tcatch ",
16332 0/*allow-unknown*/, &cmdlist);
16333
44feb3ce
TT
16334 add_catch_command ("fork", _("Catch calls to fork."),
16335 catch_fork_command_1,
a96d9b2e 16336 NULL,
44feb3ce
TT
16337 (void *) (uintptr_t) catch_fork_permanent,
16338 (void *) (uintptr_t) catch_fork_temporary);
16339 add_catch_command ("vfork", _("Catch calls to vfork."),
16340 catch_fork_command_1,
a96d9b2e 16341 NULL,
44feb3ce
TT
16342 (void *) (uintptr_t) catch_vfork_permanent,
16343 (void *) (uintptr_t) catch_vfork_temporary);
16344 add_catch_command ("exec", _("Catch calls to exec."),
16345 catch_exec_command_1,
a96d9b2e
SDJ
16346 NULL,
16347 CATCH_PERMANENT,
16348 CATCH_TEMPORARY);
edcc5120
TT
16349 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16350Usage: catch load [REGEX]\n\
16351If REGEX is given, only stop for libraries matching the regular expression."),
16352 catch_load_command_1,
16353 NULL,
16354 CATCH_PERMANENT,
16355 CATCH_TEMPORARY);
16356 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16357Usage: catch unload [REGEX]\n\
16358If REGEX is given, only stop for libraries matching the regular expression."),
16359 catch_unload_command_1,
16360 NULL,
16361 CATCH_PERMANENT,
16362 CATCH_TEMPORARY);
c5aa993b 16363
1bedd215
AC
16364 c = add_com ("watch", class_breakpoint, watch_command, _("\
16365Set a watchpoint for an expression.\n\
06a64a0b 16366Usage: watch [-l|-location] EXPRESSION\n\
c906108c 16367A watchpoint stops execution of your program whenever the value of\n\
06a64a0b
TT
16368an expression changes.\n\
16369If -l or -location is given, this evaluates EXPRESSION and watches\n\
16370the memory to which it refers."));
65d12d83 16371 set_cmd_completer (c, expression_completer);
c906108c 16372
1bedd215
AC
16373 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
16374Set a read watchpoint for an expression.\n\
06a64a0b 16375Usage: rwatch [-l|-location] EXPRESSION\n\
c906108c 16376A watchpoint stops execution of your program whenever the value of\n\
06a64a0b
TT
16377an expression is read.\n\
16378If -l or -location is given, this evaluates EXPRESSION and watches\n\
16379the memory to which it refers."));
65d12d83 16380 set_cmd_completer (c, expression_completer);
c906108c 16381
1bedd215
AC
16382 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
16383Set a watchpoint for an expression.\n\
06a64a0b 16384Usage: awatch [-l|-location] EXPRESSION\n\
c906108c 16385A watchpoint stops execution of your program whenever the value of\n\
06a64a0b
TT
16386an expression is either read or written.\n\
16387If -l or -location is given, this evaluates EXPRESSION and watches\n\
16388the memory to which it refers."));
65d12d83 16389 set_cmd_completer (c, expression_completer);
c906108c 16390
d77f58be 16391 add_info ("watchpoints", watchpoints_info, _("\
e5a67952 16392Status of specified watchpoints (all watchpoints if no argument)."));
c906108c 16393
920d2a44
AC
16394 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16395 respond to changes - contrary to the description. */
85c07804
AC
16396 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
16397 &can_use_hw_watchpoints, _("\
16398Set debugger's willingness to use watchpoint hardware."), _("\
16399Show debugger's willingness to use watchpoint hardware."), _("\
c906108c
SS
16400If zero, gdb will not use hardware for new watchpoints, even if\n\
16401such is available. (However, any hardware watchpoints that were\n\
16402created before setting this to nonzero, will continue to use watchpoint\n\
85c07804
AC
16403hardware.)"),
16404 NULL,
920d2a44 16405 show_can_use_hw_watchpoints,
85c07804 16406 &setlist, &showlist);
c906108c
SS
16407
16408 can_use_hw_watchpoints = 1;
fa8d40ab 16409
1042e4c0
SS
16410 /* Tracepoint manipulation commands. */
16411
16412 c = add_com ("trace", class_breakpoint, trace_command, _("\
629500fa 16413Set a tracepoint at specified location.\n\
1042e4c0
SS
16414\n"
16415BREAK_ARGS_HELP ("trace") "\n\
16416Do \"help tracepoints\" for info on other tracepoint commands."));
16417 set_cmd_completer (c, location_completer);
16418
16419 add_com_alias ("tp", "trace", class_alias, 0);
16420 add_com_alias ("tr", "trace", class_alias, 1);
16421 add_com_alias ("tra", "trace", class_alias, 1);
16422 add_com_alias ("trac", "trace", class_alias, 1);
16423
7a697b8d 16424 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
629500fa 16425Set a fast tracepoint at specified location.\n\
7a697b8d
SS
16426\n"
16427BREAK_ARGS_HELP ("ftrace") "\n\
16428Do \"help tracepoints\" for info on other tracepoint commands."));
16429 set_cmd_completer (c, location_completer);
16430
0fb4aa4b 16431 c = add_com ("strace", class_breakpoint, strace_command, _("\
629500fa 16432Set a static tracepoint at location or marker.\n\
0fb4aa4b
PA
16433\n\
16434strace [LOCATION] [if CONDITION]\n\
629500fa
KS
16435LOCATION may be a linespec, explicit, or address location (described below) \n\
16436or -m MARKER_ID.\n\n\
16437If a marker id is specified, probe the marker with that name. With\n\
16438no LOCATION, uses current execution address of the selected stack frame.\n\
0fb4aa4b
PA
16439Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16440This collects arbitrary user data passed in the probe point call to the\n\
16441tracing library. You can inspect it when analyzing the trace buffer,\n\
16442by printing the $_sdata variable like any other convenience variable.\n\
16443\n\
16444CONDITION is a boolean expression.\n\
629500fa 16445\n" LOCATION_HELP_STRING "\n\
d41c0fc8
PA
16446Multiple tracepoints at one place are permitted, and useful if their\n\
16447conditions are different.\n\
0fb4aa4b
PA
16448\n\
16449Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16450Do \"help tracepoints\" for info on other tracepoint commands."));
16451 set_cmd_completer (c, location_completer);
16452
1042e4c0 16453 add_info ("tracepoints", tracepoints_info, _("\
e5a67952 16454Status of specified tracepoints (all tracepoints if no argument).\n\
1042e4c0
SS
16455Convenience variable \"$tpnum\" contains the number of the\n\
16456last tracepoint set."));
16457
16458 add_info_alias ("tp", "tracepoints", 1);
16459
16460 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
16461Delete specified tracepoints.\n\
16462Arguments are tracepoint numbers, separated by spaces.\n\
16463No argument means delete all tracepoints."),
16464 &deletelist);
7e20dfcd 16465 add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
1042e4c0
SS
16466
16467 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
16468Disable specified tracepoints.\n\
16469Arguments are tracepoint numbers, separated by spaces.\n\
16470No argument means disable all tracepoints."),
16471 &disablelist);
16472 deprecate_cmd (c, "disable");
16473
16474 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
16475Enable specified tracepoints.\n\
16476Arguments are tracepoint numbers, separated by spaces.\n\
16477No argument means enable all tracepoints."),
16478 &enablelist);
16479 deprecate_cmd (c, "enable");
16480
16481 add_com ("passcount", class_trace, trace_pass_command, _("\
16482Set the passcount for a tracepoint.\n\
16483The trace will end when the tracepoint has been passed 'count' times.\n\
16484Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16485if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16486
6149aea9
PA
16487 add_prefix_cmd ("save", class_breakpoint, save_command,
16488 _("Save breakpoint definitions as a script."),
16489 &save_cmdlist, "save ",
16490 0/*allow-unknown*/, &cmdlist);
16491
16492 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
16493Save current breakpoint definitions as a script.\n\
cce7e648 16494This includes all types of breakpoints (breakpoints, watchpoints,\n\
6149aea9
PA
16495catchpoints, tracepoints). Use the 'source' command in another debug\n\
16496session to restore them."),
16497 &save_cmdlist);
16498 set_cmd_completer (c, filename_completer);
16499
16500 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
1042e4c0 16501Save current tracepoint definitions as a script.\n\
6149aea9
PA
16502Use the 'source' command in another debug session to restore them."),
16503 &save_cmdlist);
1042e4c0
SS
16504 set_cmd_completer (c, filename_completer);
16505
6149aea9
PA
16506 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
16507 deprecate_cmd (c, "save tracepoints");
16508
1bedd215 16509 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
fa8d40ab
JJ
16510Breakpoint specific settings\n\
16511Configure various breakpoint-specific variables such as\n\
1bedd215 16512pending breakpoint behavior"),
fa8d40ab
JJ
16513 &breakpoint_set_cmdlist, "set breakpoint ",
16514 0/*allow-unknown*/, &setlist);
1bedd215 16515 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
fa8d40ab
JJ
16516Breakpoint specific settings\n\
16517Configure various breakpoint-specific variables such as\n\
1bedd215 16518pending breakpoint behavior"),
fa8d40ab
JJ
16519 &breakpoint_show_cmdlist, "show breakpoint ",
16520 0/*allow-unknown*/, &showlist);
16521
7915a72c
AC
16522 add_setshow_auto_boolean_cmd ("pending", no_class,
16523 &pending_break_support, _("\
16524Set debugger's behavior regarding pending breakpoints."), _("\
16525Show debugger's behavior regarding pending breakpoints."), _("\
6e1d7d6c
AC
16526If on, an unrecognized breakpoint location will cause gdb to create a\n\
16527pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16528an error. If auto, an unrecognized breakpoint location results in a\n\
7915a72c 16529user-query to see if a pending breakpoint should be created."),
2c5b56ce 16530 NULL,
920d2a44 16531 show_pending_break_support,
6e1d7d6c
AC
16532 &breakpoint_set_cmdlist,
16533 &breakpoint_show_cmdlist);
fa8d40ab
JJ
16534
16535 pending_break_support = AUTO_BOOLEAN_AUTO;
765dc015
VP
16536
16537 add_setshow_boolean_cmd ("auto-hw", no_class,
16538 &automatic_hardware_breakpoints, _("\
16539Set automatic usage of hardware breakpoints."), _("\
16540Show automatic usage of hardware breakpoints."), _("\
16541If set, the debugger will automatically use hardware breakpoints for\n\
16542breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16543a warning will be emitted for such breakpoints."),
16544 NULL,
16545 show_automatic_hardware_breakpoints,
16546 &breakpoint_set_cmdlist,
16547 &breakpoint_show_cmdlist);
74960c60 16548
a25a5a45
PA
16549 add_setshow_boolean_cmd ("always-inserted", class_support,
16550 &always_inserted_mode, _("\
74960c60
VP
16551Set mode for inserting breakpoints."), _("\
16552Show mode for inserting breakpoints."), _("\
a25a5a45
PA
16553When this mode is on, breakpoints are inserted immediately as soon as\n\
16554they're created, kept inserted even when execution stops, and removed\n\
16555only when the user deletes them. When this mode is off (the default),\n\
16556breakpoints are inserted only when execution continues, and removed\n\
16557when execution stops."),
72d0e2c5
YQ
16558 NULL,
16559 &show_always_inserted_mode,
16560 &breakpoint_set_cmdlist,
16561 &breakpoint_show_cmdlist);
f1310107 16562
b775012e
LM
16563 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
16564 condition_evaluation_enums,
16565 &condition_evaluation_mode_1, _("\
16566Set mode of breakpoint condition evaluation."), _("\
16567Show mode of breakpoint condition evaluation."), _("\
d1cda5d9 16568When this is set to \"host\", breakpoint conditions will be\n\
b775012e
LM
16569evaluated on the host's side by GDB. When it is set to \"target\",\n\
16570breakpoint conditions will be downloaded to the target (if the target\n\
16571supports such feature) and conditions will be evaluated on the target's side.\n\
16572If this is set to \"auto\" (default), this will be automatically set to\n\
16573\"target\" if it supports condition evaluation, otherwise it will\n\
16574be set to \"gdb\""),
16575 &set_condition_evaluation_mode,
16576 &show_condition_evaluation_mode,
16577 &breakpoint_set_cmdlist,
16578 &breakpoint_show_cmdlist);
16579
f1310107
TJB
16580 add_com ("break-range", class_breakpoint, break_range_command, _("\
16581Set a breakpoint for an address range.\n\
16582break-range START-LOCATION, END-LOCATION\n\
16583where START-LOCATION and END-LOCATION can be one of the following:\n\
16584 LINENUM, for that line in the current file,\n\
16585 FILE:LINENUM, for that line in that file,\n\
16586 +OFFSET, for that number of lines after the current line\n\
16587 or the start of the range\n\
16588 FUNCTION, for the first line in that function,\n\
16589 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16590 *ADDRESS, for the instruction at that address.\n\
16591\n\
16592The breakpoint will stop execution of the inferior whenever it executes\n\
16593an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16594range (including START-LOCATION and END-LOCATION)."));
16595
e7e0cddf 16596 c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
629500fa 16597Set a dynamic printf at specified location.\n\
e7e0cddf 16598dprintf location,format string,arg1,arg2,...\n\
629500fa
KS
16599location may be a linespec, explicit, or address location.\n"
16600"\n" LOCATION_HELP_STRING));
e7e0cddf
SS
16601 set_cmd_completer (c, location_completer);
16602
16603 add_setshow_enum_cmd ("dprintf-style", class_support,
16604 dprintf_style_enums, &dprintf_style, _("\
16605Set the style of usage for dynamic printf."), _("\
16606Show the style of usage for dynamic printf."), _("\
16607This setting chooses how GDB will do a dynamic printf.\n\
16608If the value is \"gdb\", then the printing is done by GDB to its own\n\
16609console, as with the \"printf\" command.\n\
16610If the value is \"call\", the print is done by calling a function in your\n\
16611program; by default printf(), but you can choose a different function or\n\
16612output stream by setting dprintf-function and dprintf-channel."),
16613 update_dprintf_commands, NULL,
16614 &setlist, &showlist);
16615
16616 dprintf_function = xstrdup ("printf");
16617 add_setshow_string_cmd ("dprintf-function", class_support,
16618 &dprintf_function, _("\
16619Set the function to use for dynamic printf"), _("\
16620Show the function to use for dynamic printf"), NULL,
16621 update_dprintf_commands, NULL,
16622 &setlist, &showlist);
16623
16624 dprintf_channel = xstrdup ("");
16625 add_setshow_string_cmd ("dprintf-channel", class_support,
16626 &dprintf_channel, _("\
16627Set the channel to use for dynamic printf"), _("\
16628Show the channel to use for dynamic printf"), NULL,
16629 update_dprintf_commands, NULL,
16630 &setlist, &showlist);
16631
d3ce09f5
SS
16632 add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16633 &disconnected_dprintf, _("\
16634Set whether dprintf continues after GDB disconnects."), _("\
16635Show whether dprintf continues after GDB disconnects."), _("\
16636Use this to let dprintf commands continue to hit and produce output\n\
16637even if GDB disconnects or detaches from the target."),
16638 NULL,
16639 NULL,
16640 &setlist, &showlist);
16641
16642 add_com ("agent-printf", class_vars, agent_printf_command, _("\
16643agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16644(target agent only) This is useful for formatted output in user-defined commands."));
16645
765dc015 16646 automatic_hardware_breakpoints = 1;
f3b1572e
PA
16647
16648 observer_attach_about_to_proceed (breakpoint_about_to_proceed);
49fa26b0 16649 observer_attach_thread_exit (remove_threaded_breakpoints);
c906108c 16650}
This page took 2.959364 seconds and 4 git commands to generate.