Replace some xmalloc-family functions with XNEW-family ones
[deliverable/binutils-gdb.git] / gdb / breakpoint.c
CommitLineData
c906108c 1/* Everything about breakpoints, for GDB.
8926118c 2
32d0add0 3 Copyright (C) 1986-2015 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"
f00aae0f 70#include "location.h"
d3ce09f5 71
1042e4c0
SS
72/* readline include files */
73#include "readline/readline.h"
74#include "readline/history.h"
75
76/* readline defines this. */
77#undef savestring
78
034dad6f 79#include "mi/mi-common.h"
6dddc817 80#include "extension.h"
104c1213 81
e7e8980f
YQ
82/* Enums for exception-handling support. */
83enum exception_event_kind
84{
85 EX_EVENT_THROW,
591f19e8 86 EX_EVENT_RETHROW,
e7e8980f
YQ
87 EX_EVENT_CATCH
88};
89
4a64f543 90/* Prototypes for local functions. */
c906108c 91
a14ed312 92static void enable_delete_command (char *, int);
c906108c 93
a14ed312 94static void enable_once_command (char *, int);
c906108c 95
816338b5
SS
96static void enable_count_command (char *, int);
97
a14ed312 98static void disable_command (char *, int);
c906108c 99
a14ed312 100static void enable_command (char *, int);
c906108c 101
95a42b64
TT
102static void map_breakpoint_numbers (char *, void (*) (struct breakpoint *,
103 void *),
104 void *);
c906108c 105
a14ed312 106static void ignore_command (char *, int);
c906108c 107
4efb68b1 108static int breakpoint_re_set_one (void *);
c906108c 109
348d480f
PA
110static void breakpoint_re_set_default (struct breakpoint *);
111
f00aae0f
KS
112static void
113 create_sals_from_location_default (const struct event_location *location,
114 struct linespec_result *canonical,
115 enum bptype type_wanted);
983af33b
SDJ
116
117static void create_breakpoints_sal_default (struct gdbarch *,
118 struct linespec_result *,
e7e0cddf 119 char *, char *, enum bptype,
983af33b
SDJ
120 enum bpdisp, int, int,
121 int,
122 const struct breakpoint_ops *,
44f238bb 123 int, int, int, unsigned);
983af33b 124
f00aae0f
KS
125static void decode_location_default (struct breakpoint *b,
126 const struct event_location *location,
127 struct symtabs_and_lines *sals);
983af33b 128
a14ed312 129static void clear_command (char *, int);
c906108c 130
a14ed312 131static void catch_command (char *, int);
c906108c 132
a9634178 133static int can_use_hardware_watchpoint (struct value *);
c906108c 134
98deb0da 135static void break_command_1 (char *, int, int);
c906108c 136
a14ed312 137static void mention (struct breakpoint *);
c906108c 138
348d480f
PA
139static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
140 enum bptype,
c0a91b2b 141 const struct breakpoint_ops *);
3742cc8b
YQ
142static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
143 const struct symtab_and_line *);
144
4a64f543
MS
145/* This function is used in gdbtk sources and thus can not be made
146 static. */
63c252f8 147struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
348d480f 148 struct symtab_and_line,
c0a91b2b
TT
149 enum bptype,
150 const struct breakpoint_ops *);
c906108c 151
06edf0c0
PA
152static struct breakpoint *
153 momentary_breakpoint_from_master (struct breakpoint *orig,
154 enum bptype type,
a1aa2221
LM
155 const struct breakpoint_ops *ops,
156 int loc_enabled);
06edf0c0 157
76897487
KB
158static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
159
a6d9a66e
UW
160static CORE_ADDR adjust_breakpoint_address (struct gdbarch *gdbarch,
161 CORE_ADDR bpaddr,
88f7da05 162 enum bptype bptype);
76897487 163
6c95b8df
PA
164static void describe_other_breakpoints (struct gdbarch *,
165 struct program_space *, CORE_ADDR,
5af949e3 166 struct obj_section *, int);
c906108c 167
85d721b8
PA
168static int watchpoint_locations_match (struct bp_location *loc1,
169 struct bp_location *loc2);
170
f1310107
TJB
171static int breakpoint_location_address_match (struct bp_location *bl,
172 struct address_space *aspace,
173 CORE_ADDR addr);
174
a14ed312 175static void breakpoints_info (char *, int);
c906108c 176
d77f58be
SS
177static void watchpoints_info (char *, int);
178
e5a67952
MS
179static int breakpoint_1 (char *, int,
180 int (*) (const struct breakpoint *));
c906108c 181
4efb68b1 182static int breakpoint_cond_eval (void *);
c906108c 183
4efb68b1 184static void cleanup_executing_breakpoints (void *);
c906108c 185
a14ed312 186static void commands_command (char *, int);
c906108c 187
a14ed312 188static void condition_command (char *, int);
c906108c 189
c5aa993b
JM
190typedef enum
191 {
192 mark_inserted,
193 mark_uninserted
194 }
195insertion_state_t;
c906108c 196
0bde7532 197static int remove_breakpoint (struct bp_location *, insertion_state_t);
6c95b8df 198static int remove_breakpoint_1 (struct bp_location *, insertion_state_t);
c906108c 199
e514a9d6 200static enum print_stop_action print_bp_stop_message (bpstat bs);
c906108c 201
4efb68b1 202static int watchpoint_check (void *);
c906108c 203
a14ed312 204static void maintenance_info_breakpoints (char *, int);
c906108c 205
a14ed312 206static int hw_breakpoint_used_count (void);
c906108c 207
a1398e0c
PA
208static int hw_watchpoint_use_count (struct breakpoint *);
209
210static int hw_watchpoint_used_count_others (struct breakpoint *except,
211 enum bptype type,
212 int *other_type_used);
c906108c 213
a14ed312 214static void hbreak_command (char *, int);
c906108c 215
a14ed312 216static void thbreak_command (char *, int);
c906108c 217
816338b5
SS
218static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
219 int count);
c906108c 220
a14ed312 221static void stop_command (char *arg, int from_tty);
7a292a7a 222
a14ed312 223static void stopin_command (char *arg, int from_tty);
7a292a7a 224
a14ed312 225static void stopat_command (char *arg, int from_tty);
7a292a7a 226
a14ed312 227static void tcatch_command (char *arg, int from_tty);
7a292a7a 228
fe3f5fa8 229static void free_bp_location (struct bp_location *loc);
f431efe5
PA
230static void incref_bp_location (struct bp_location *loc);
231static void decref_bp_location (struct bp_location **loc);
fe3f5fa8 232
39d61571 233static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
a5606eee 234
44702360
PA
235/* update_global_location_list's modes of operation wrt to whether to
236 insert locations now. */
237enum ugll_insert_mode
238{
239 /* Don't insert any breakpoint locations into the inferior, only
240 remove already-inserted locations that no longer should be
241 inserted. Functions that delete a breakpoint or breakpoints
242 should specify this mode, so that deleting a breakpoint doesn't
243 have the side effect of inserting the locations of other
244 breakpoints that are marked not-inserted, but should_be_inserted
245 returns true on them.
246
247 This behavior is useful is situations close to tear-down -- e.g.,
248 after an exec, while the target still has execution, but
249 breakpoint shadows of the previous executable image should *NOT*
250 be restored to the new image; or before detaching, where the
251 target still has execution and wants to delete breakpoints from
252 GDB's lists, and all breakpoints had already been removed from
253 the inferior. */
254 UGLL_DONT_INSERT,
255
a25a5a45
PA
256 /* May insert breakpoints iff breakpoints_should_be_inserted_now
257 claims breakpoints should be inserted now. */
04086b45
PA
258 UGLL_MAY_INSERT,
259
a25a5a45
PA
260 /* Insert locations now, irrespective of
261 breakpoints_should_be_inserted_now. E.g., say all threads are
262 stopped right now, and the user did "continue". We need to
263 insert breakpoints _before_ resuming the target, but
264 UGLL_MAY_INSERT wouldn't insert them, because
265 breakpoints_should_be_inserted_now returns false at that point,
266 as no thread is running yet. */
04086b45 267 UGLL_INSERT
44702360
PA
268};
269
270static void update_global_location_list (enum ugll_insert_mode);
a5606eee 271
44702360 272static void update_global_location_list_nothrow (enum ugll_insert_mode);
74960c60 273
d77f58be 274static int is_hardware_watchpoint (const struct breakpoint *bpt);
74960c60
VP
275
276static void insert_breakpoint_locations (void);
a5606eee 277
1042e4c0
SS
278static void tracepoints_info (char *, int);
279
280static void delete_trace_command (char *, int);
281
282static void enable_trace_command (char *, int);
283
284static void disable_trace_command (char *, int);
285
286static void trace_pass_command (char *, int);
287
558a9d82
YQ
288static void set_tracepoint_count (int num);
289
9c06b0b4
TJB
290static int is_masked_watchpoint (const struct breakpoint *b);
291
b775012e
LM
292static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
293
983af33b
SDJ
294/* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
295 otherwise. */
296
297static int strace_marker_p (struct breakpoint *b);
0fb4aa4b 298
2060206e
PA
299/* The breakpoint_ops structure to be inherited by all breakpoint_ops
300 that are implemented on top of software or hardware breakpoints
301 (user breakpoints, internal and momentary breakpoints, etc.). */
302static struct breakpoint_ops bkpt_base_breakpoint_ops;
303
304/* Internal breakpoints class type. */
06edf0c0 305static struct breakpoint_ops internal_breakpoint_ops;
2060206e
PA
306
307/* Momentary breakpoints class type. */
06edf0c0
PA
308static struct breakpoint_ops momentary_breakpoint_ops;
309
e2e4d78b
JK
310/* Momentary breakpoints for bp_longjmp and bp_exception class type. */
311static struct breakpoint_ops longjmp_breakpoint_ops;
312
2060206e
PA
313/* The breakpoint_ops structure to be used in regular user created
314 breakpoints. */
315struct breakpoint_ops bkpt_breakpoint_ops;
316
55aa24fb
SDJ
317/* Breakpoints set on probes. */
318static struct breakpoint_ops bkpt_probe_breakpoint_ops;
319
e7e0cddf 320/* Dynamic printf class type. */
c5867ab6 321struct breakpoint_ops dprintf_breakpoint_ops;
e7e0cddf 322
d3ce09f5
SS
323/* The style in which to perform a dynamic printf. This is a user
324 option because different output options have different tradeoffs;
325 if GDB does the printing, there is better error handling if there
326 is a problem with any of the arguments, but using an inferior
327 function lets you have special-purpose printers and sending of
328 output to the same place as compiled-in print functions. */
329
330static const char dprintf_style_gdb[] = "gdb";
331static const char dprintf_style_call[] = "call";
332static const char dprintf_style_agent[] = "agent";
333static const char *const dprintf_style_enums[] = {
334 dprintf_style_gdb,
335 dprintf_style_call,
336 dprintf_style_agent,
337 NULL
338};
339static const char *dprintf_style = dprintf_style_gdb;
340
341/* The function to use for dynamic printf if the preferred style is to
342 call into the inferior. The value is simply a string that is
343 copied into the command, so it can be anything that GDB can
344 evaluate to a callable address, not necessarily a function name. */
345
346static char *dprintf_function = "";
347
348/* The channel to use for dynamic printf if the preferred style is to
349 call into the inferior; if a nonempty string, it will be passed to
350 the call as the first argument, with the format string as the
351 second. As with the dprintf function, this can be anything that
352 GDB knows how to evaluate, so in addition to common choices like
353 "stderr", this could be an app-specific expression like
354 "mystreams[curlogger]". */
355
356static char *dprintf_channel = "";
357
358/* True if dprintf commands should continue to operate even if GDB
359 has disconnected. */
360static int disconnected_dprintf = 1;
361
5cea2a26
PA
362/* A reference-counted struct command_line. This lets multiple
363 breakpoints share a single command list. */
364struct counted_command_line
365{
366 /* The reference count. */
367 int refc;
368
369 /* The command list. */
370 struct command_line *commands;
371};
372
373struct command_line *
374breakpoint_commands (struct breakpoint *b)
375{
376 return b->commands ? b->commands->commands : NULL;
377}
3daf8fe5 378
f3b1572e
PA
379/* Flag indicating that a command has proceeded the inferior past the
380 current breakpoint. */
381
382static int breakpoint_proceeded;
383
956a9fb9 384const char *
2cec12e5
AR
385bpdisp_text (enum bpdisp disp)
386{
4a64f543
MS
387 /* NOTE: the following values are a part of MI protocol and
388 represent values of 'disp' field returned when inferior stops at
389 a breakpoint. */
bc043ef3 390 static const char * const bpdisps[] = {"del", "dstp", "dis", "keep"};
cc59ec59 391
2cec12e5
AR
392 return bpdisps[(int) disp];
393}
c906108c 394
4a64f543 395/* Prototypes for exported functions. */
c906108c 396/* If FALSE, gdb will not use hardware support for watchpoints, even
4a64f543 397 if such is available. */
c906108c
SS
398static int can_use_hw_watchpoints;
399
920d2a44
AC
400static void
401show_can_use_hw_watchpoints (struct ui_file *file, int from_tty,
402 struct cmd_list_element *c,
403 const char *value)
404{
3e43a32a
MS
405 fprintf_filtered (file,
406 _("Debugger's willingness to use "
407 "watchpoint hardware is %s.\n"),
920d2a44
AC
408 value);
409}
410
fa8d40ab
JJ
411/* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
412 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
4a64f543 413 for unrecognized breakpoint locations.
fa8d40ab
JJ
414 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
415static enum auto_boolean pending_break_support;
920d2a44
AC
416static void
417show_pending_break_support (struct ui_file *file, int from_tty,
418 struct cmd_list_element *c,
419 const char *value)
420{
3e43a32a
MS
421 fprintf_filtered (file,
422 _("Debugger's behavior regarding "
423 "pending breakpoints is %s.\n"),
920d2a44
AC
424 value);
425}
fa8d40ab 426
765dc015 427/* If 1, gdb will automatically use hardware breakpoints for breakpoints
4a64f543 428 set with "break" but falling in read-only memory.
765dc015
VP
429 If 0, gdb will warn about such breakpoints, but won't automatically
430 use hardware breakpoints. */
431static int automatic_hardware_breakpoints;
432static void
433show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
434 struct cmd_list_element *c,
435 const char *value)
436{
3e43a32a
MS
437 fprintf_filtered (file,
438 _("Automatic usage of hardware breakpoints is %s.\n"),
765dc015
VP
439 value);
440}
441
a25a5a45
PA
442/* If on, GDB keeps breakpoints inserted even if the inferior is
443 stopped, and immediately inserts any new breakpoints as soon as
444 they're created. If off (default), GDB keeps breakpoints off of
445 the target as long as possible. That is, it delays inserting
446 breakpoints until the next resume, and removes them again when the
447 target fully stops. This is a bit safer in case GDB crashes while
448 processing user input. */
449static int always_inserted_mode = 0;
72d0e2c5 450
33e5cbd6 451static void
74960c60 452show_always_inserted_mode (struct ui_file *file, int from_tty,
33e5cbd6 453 struct cmd_list_element *c, const char *value)
74960c60 454{
a25a5a45
PA
455 fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
456 value);
74960c60
VP
457}
458
b57bacec
PA
459/* See breakpoint.h. */
460
33e5cbd6 461int
a25a5a45 462breakpoints_should_be_inserted_now (void)
33e5cbd6 463{
a25a5a45
PA
464 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
465 {
466 /* If breakpoints are global, they should be inserted even if no
467 thread under gdb's control is running, or even if there are
468 no threads under GDB's control yet. */
469 return 1;
470 }
471 else if (target_has_execution)
472 {
372316f1
PA
473 struct thread_info *tp;
474
a25a5a45
PA
475 if (always_inserted_mode)
476 {
477 /* The user wants breakpoints inserted even if all threads
478 are stopped. */
479 return 1;
480 }
481
b57bacec
PA
482 if (threads_are_executing ())
483 return 1;
372316f1
PA
484
485 /* Don't remove breakpoints yet if, even though all threads are
486 stopped, we still have events to process. */
487 ALL_NON_EXITED_THREADS (tp)
488 if (tp->resumed
489 && tp->suspend.waitstatus_pending_p)
490 return 1;
a25a5a45
PA
491 }
492 return 0;
33e5cbd6 493}
765dc015 494
b775012e
LM
495static const char condition_evaluation_both[] = "host or target";
496
497/* Modes for breakpoint condition evaluation. */
498static const char condition_evaluation_auto[] = "auto";
499static const char condition_evaluation_host[] = "host";
500static const char condition_evaluation_target[] = "target";
501static const char *const condition_evaluation_enums[] = {
502 condition_evaluation_auto,
503 condition_evaluation_host,
504 condition_evaluation_target,
505 NULL
506};
507
508/* Global that holds the current mode for breakpoint condition evaluation. */
509static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
510
511/* Global that we use to display information to the user (gets its value from
512 condition_evaluation_mode_1. */
513static const char *condition_evaluation_mode = condition_evaluation_auto;
514
515/* Translate a condition evaluation mode MODE into either "host"
516 or "target". This is used mostly to translate from "auto" to the
517 real setting that is being used. It returns the translated
518 evaluation mode. */
519
520static const char *
521translate_condition_evaluation_mode (const char *mode)
522{
523 if (mode == condition_evaluation_auto)
524 {
525 if (target_supports_evaluation_of_breakpoint_conditions ())
526 return condition_evaluation_target;
527 else
528 return condition_evaluation_host;
529 }
530 else
531 return mode;
532}
533
534/* Discovers what condition_evaluation_auto translates to. */
535
536static const char *
537breakpoint_condition_evaluation_mode (void)
538{
539 return translate_condition_evaluation_mode (condition_evaluation_mode);
540}
541
542/* Return true if GDB should evaluate breakpoint conditions or false
543 otherwise. */
544
545static int
546gdb_evaluates_breakpoint_condition_p (void)
547{
548 const char *mode = breakpoint_condition_evaluation_mode ();
549
550 return (mode == condition_evaluation_host);
551}
552
a14ed312 553void _initialize_breakpoint (void);
c906108c 554
c906108c
SS
555/* Are we executing breakpoint commands? */
556static int executing_breakpoint_commands;
557
c02f5703
MS
558/* Are overlay event breakpoints enabled? */
559static int overlay_events_enabled;
560
e09342b5
TJB
561/* See description in breakpoint.h. */
562int target_exact_watchpoints = 0;
563
c906108c 564/* Walk the following statement or block through all breakpoints.
e5dd4106 565 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
4a64f543 566 current breakpoint. */
c906108c 567
5c44784c 568#define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
c906108c 569
5c44784c
JM
570#define ALL_BREAKPOINTS_SAFE(B,TMP) \
571 for (B = breakpoint_chain; \
572 B ? (TMP=B->next, 1): 0; \
573 B = TMP)
c906108c 574
4a64f543
MS
575/* Similar iterator for the low-level breakpoints. SAFE variant is
576 not provided so update_global_location_list must not be called
577 while executing the block of ALL_BP_LOCATIONS. */
7cc221ef 578
876fa593
JK
579#define ALL_BP_LOCATIONS(B,BP_TMP) \
580 for (BP_TMP = bp_location; \
581 BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
582 BP_TMP++)
7cc221ef 583
b775012e
LM
584/* Iterates through locations with address ADDRESS for the currently selected
585 program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
586 to where the loop should start from.
587 If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
588 appropriate location to start with. */
589
590#define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
591 for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
592 BP_LOCP_TMP = BP_LOCP_START; \
593 BP_LOCP_START \
594 && (BP_LOCP_TMP < bp_location + bp_location_count \
595 && (*BP_LOCP_TMP)->address == ADDRESS); \
596 BP_LOCP_TMP++)
597
1042e4c0
SS
598/* Iterator for tracepoints only. */
599
600#define ALL_TRACEPOINTS(B) \
601 for (B = breakpoint_chain; B; B = B->next) \
d77f58be 602 if (is_tracepoint (B))
1042e4c0 603
7cc221ef 604/* Chains of all breakpoints defined. */
c906108c
SS
605
606struct breakpoint *breakpoint_chain;
607
876fa593
JK
608/* Array is sorted by bp_location_compare - primarily by the ADDRESS. */
609
610static struct bp_location **bp_location;
611
612/* Number of elements of BP_LOCATION. */
613
614static unsigned bp_location_count;
615
4a64f543
MS
616/* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
617 ADDRESS for the current elements of BP_LOCATION which get a valid
618 result from bp_location_has_shadow. You can use it for roughly
619 limiting the subrange of BP_LOCATION to scan for shadow bytes for
620 an address you need to read. */
876fa593
JK
621
622static CORE_ADDR bp_location_placed_address_before_address_max;
623
4a64f543
MS
624/* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
625 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
626 BP_LOCATION which get a valid result from bp_location_has_shadow.
627 You can use it for roughly limiting the subrange of BP_LOCATION to
628 scan for shadow bytes for an address you need to read. */
876fa593
JK
629
630static CORE_ADDR bp_location_shadow_len_after_address_max;
7cc221ef 631
4a64f543
MS
632/* The locations that no longer correspond to any breakpoint, unlinked
633 from bp_location array, but for which a hit may still be reported
634 by a target. */
20874c92
VP
635VEC(bp_location_p) *moribund_locations = NULL;
636
c906108c
SS
637/* Number of last breakpoint made. */
638
95a42b64
TT
639static int breakpoint_count;
640
86b17b60
PA
641/* The value of `breakpoint_count' before the last command that
642 created breakpoints. If the last (break-like) command created more
643 than one breakpoint, then the difference between BREAKPOINT_COUNT
644 and PREV_BREAKPOINT_COUNT is more than one. */
645static int prev_breakpoint_count;
c906108c 646
1042e4c0
SS
647/* Number of last tracepoint made. */
648
95a42b64 649static int tracepoint_count;
1042e4c0 650
6149aea9
PA
651static struct cmd_list_element *breakpoint_set_cmdlist;
652static struct cmd_list_element *breakpoint_show_cmdlist;
9291a0cd 653struct cmd_list_element *save_cmdlist;
6149aea9 654
badd37ce
SDJ
655/* See declaration at breakpoint.h. */
656
657struct breakpoint *
658breakpoint_find_if (int (*func) (struct breakpoint *b, void *d),
659 void *user_data)
660{
661 struct breakpoint *b = NULL;
662
663 ALL_BREAKPOINTS (b)
664 {
665 if (func (b, user_data) != 0)
666 break;
667 }
668
669 return b;
670}
671
468d015d
JJ
672/* Return whether a breakpoint is an active enabled breakpoint. */
673static int
674breakpoint_enabled (struct breakpoint *b)
675{
0d381245 676 return (b->enable_state == bp_enabled);
468d015d
JJ
677}
678
c906108c
SS
679/* Set breakpoint count to NUM. */
680
95a42b64 681static void
fba45db2 682set_breakpoint_count (int num)
c906108c 683{
86b17b60 684 prev_breakpoint_count = breakpoint_count;
c906108c 685 breakpoint_count = num;
4fa62494 686 set_internalvar_integer (lookup_internalvar ("bpnum"), num);
c906108c
SS
687}
688
86b17b60
PA
689/* Used by `start_rbreak_breakpoints' below, to record the current
690 breakpoint count before "rbreak" creates any breakpoint. */
691static int rbreak_start_breakpoint_count;
692
95a42b64
TT
693/* Called at the start an "rbreak" command to record the first
694 breakpoint made. */
86b17b60 695
95a42b64
TT
696void
697start_rbreak_breakpoints (void)
698{
86b17b60 699 rbreak_start_breakpoint_count = breakpoint_count;
95a42b64
TT
700}
701
702/* Called at the end of an "rbreak" command to record the last
703 breakpoint made. */
86b17b60 704
95a42b64
TT
705void
706end_rbreak_breakpoints (void)
707{
86b17b60 708 prev_breakpoint_count = rbreak_start_breakpoint_count;
95a42b64
TT
709}
710
4a64f543 711/* Used in run_command to zero the hit count when a new run starts. */
c906108c
SS
712
713void
fba45db2 714clear_breakpoint_hit_counts (void)
c906108c
SS
715{
716 struct breakpoint *b;
717
718 ALL_BREAKPOINTS (b)
719 b->hit_count = 0;
720}
721
9add0f1b
TT
722/* Allocate a new counted_command_line with reference count of 1.
723 The new structure owns COMMANDS. */
724
725static struct counted_command_line *
726alloc_counted_command_line (struct command_line *commands)
727{
8d749320 728 struct counted_command_line *result = XNEW (struct counted_command_line);
cc59ec59 729
9add0f1b
TT
730 result->refc = 1;
731 result->commands = commands;
8d749320 732
9add0f1b
TT
733 return result;
734}
735
736/* Increment reference count. This does nothing if CMD is NULL. */
737
738static void
739incref_counted_command_line (struct counted_command_line *cmd)
740{
741 if (cmd)
742 ++cmd->refc;
743}
744
745/* Decrement reference count. If the reference count reaches 0,
746 destroy the counted_command_line. Sets *CMDP to NULL. This does
747 nothing if *CMDP is NULL. */
748
749static void
750decref_counted_command_line (struct counted_command_line **cmdp)
751{
752 if (*cmdp)
753 {
754 if (--(*cmdp)->refc == 0)
755 {
756 free_command_lines (&(*cmdp)->commands);
757 xfree (*cmdp);
758 }
759 *cmdp = NULL;
760 }
761}
762
763/* A cleanup function that calls decref_counted_command_line. */
764
765static void
766do_cleanup_counted_command_line (void *arg)
767{
768 decref_counted_command_line (arg);
769}
770
771/* Create a cleanup that calls decref_counted_command_line on the
772 argument. */
773
774static struct cleanup *
775make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
776{
777 return make_cleanup (do_cleanup_counted_command_line, cmdp);
778}
779
c906108c 780\f
48cb2d85
VP
781/* Return the breakpoint with the specified number, or NULL
782 if the number does not refer to an existing breakpoint. */
783
784struct breakpoint *
785get_breakpoint (int num)
786{
787 struct breakpoint *b;
788
789 ALL_BREAKPOINTS (b)
790 if (b->number == num)
791 return b;
792
793 return NULL;
794}
5c44784c 795
c906108c 796\f
adc36818 797
b775012e
LM
798/* Mark locations as "conditions have changed" in case the target supports
799 evaluating conditions on its side. */
800
801static void
802mark_breakpoint_modified (struct breakpoint *b)
803{
804 struct bp_location *loc;
805
806 /* This is only meaningful if the target is
807 evaluating conditions and if the user has
808 opted for condition evaluation on the target's
809 side. */
810 if (gdb_evaluates_breakpoint_condition_p ()
811 || !target_supports_evaluation_of_breakpoint_conditions ())
812 return;
813
814 if (!is_breakpoint (b))
815 return;
816
817 for (loc = b->loc; loc; loc = loc->next)
818 loc->condition_changed = condition_modified;
819}
820
821/* Mark location as "conditions have changed" in case the target supports
822 evaluating conditions on its side. */
823
824static void
825mark_breakpoint_location_modified (struct bp_location *loc)
826{
827 /* This is only meaningful if the target is
828 evaluating conditions and if the user has
829 opted for condition evaluation on the target's
830 side. */
831 if (gdb_evaluates_breakpoint_condition_p ()
832 || !target_supports_evaluation_of_breakpoint_conditions ())
833
834 return;
835
836 if (!is_breakpoint (loc->owner))
837 return;
838
839 loc->condition_changed = condition_modified;
840}
841
842/* Sets the condition-evaluation mode using the static global
843 condition_evaluation_mode. */
844
845static void
846set_condition_evaluation_mode (char *args, int from_tty,
847 struct cmd_list_element *c)
848{
b775012e
LM
849 const char *old_mode, *new_mode;
850
851 if ((condition_evaluation_mode_1 == condition_evaluation_target)
852 && !target_supports_evaluation_of_breakpoint_conditions ())
853 {
854 condition_evaluation_mode_1 = condition_evaluation_mode;
855 warning (_("Target does not support breakpoint condition evaluation.\n"
856 "Using host evaluation mode instead."));
857 return;
858 }
859
860 new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
861 old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
862
abf1152a
JK
863 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
864 settings was "auto". */
865 condition_evaluation_mode = condition_evaluation_mode_1;
866
b775012e
LM
867 /* Only update the mode if the user picked a different one. */
868 if (new_mode != old_mode)
869 {
870 struct bp_location *loc, **loc_tmp;
871 /* If the user switched to a different evaluation mode, we
872 need to synch the changes with the target as follows:
873
874 "host" -> "target": Send all (valid) conditions to the target.
875 "target" -> "host": Remove all the conditions from the target.
876 */
877
b775012e
LM
878 if (new_mode == condition_evaluation_target)
879 {
880 /* Mark everything modified and synch conditions with the
881 target. */
882 ALL_BP_LOCATIONS (loc, loc_tmp)
883 mark_breakpoint_location_modified (loc);
884 }
885 else
886 {
887 /* Manually mark non-duplicate locations to synch conditions
888 with the target. We do this to remove all the conditions the
889 target knows about. */
890 ALL_BP_LOCATIONS (loc, loc_tmp)
891 if (is_breakpoint (loc->owner) && loc->inserted)
892 loc->needs_update = 1;
893 }
894
895 /* Do the update. */
44702360 896 update_global_location_list (UGLL_MAY_INSERT);
b775012e
LM
897 }
898
899 return;
900}
901
902/* Shows the current mode of breakpoint condition evaluation. Explicitly shows
903 what "auto" is translating to. */
904
905static void
906show_condition_evaluation_mode (struct ui_file *file, int from_tty,
907 struct cmd_list_element *c, const char *value)
908{
909 if (condition_evaluation_mode == condition_evaluation_auto)
910 fprintf_filtered (file,
911 _("Breakpoint condition evaluation "
912 "mode is %s (currently %s).\n"),
913 value,
914 breakpoint_condition_evaluation_mode ());
915 else
916 fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
917 value);
918}
919
920/* A comparison function for bp_location AP and BP that is used by
921 bsearch. This comparison function only cares about addresses, unlike
922 the more general bp_location_compare function. */
923
924static int
925bp_location_compare_addrs (const void *ap, const void *bp)
926{
927 struct bp_location *a = *(void **) ap;
928 struct bp_location *b = *(void **) bp;
929
930 if (a->address == b->address)
931 return 0;
932 else
933 return ((a->address > b->address) - (a->address < b->address));
934}
935
936/* Helper function to skip all bp_locations with addresses
937 less than ADDRESS. It returns the first bp_location that
938 is greater than or equal to ADDRESS. If none is found, just
939 return NULL. */
940
941static struct bp_location **
942get_first_locp_gte_addr (CORE_ADDR address)
943{
944 struct bp_location dummy_loc;
945 struct bp_location *dummy_locp = &dummy_loc;
946 struct bp_location **locp_found = NULL;
947
948 /* Initialize the dummy location's address field. */
949 memset (&dummy_loc, 0, sizeof (struct bp_location));
950 dummy_loc.address = address;
951
952 /* Find a close match to the first location at ADDRESS. */
953 locp_found = bsearch (&dummy_locp, bp_location, bp_location_count,
954 sizeof (struct bp_location **),
955 bp_location_compare_addrs);
956
957 /* Nothing was found, nothing left to do. */
958 if (locp_found == NULL)
959 return NULL;
960
961 /* We may have found a location that is at ADDRESS but is not the first in the
962 location's list. Go backwards (if possible) and locate the first one. */
963 while ((locp_found - 1) >= bp_location
964 && (*(locp_found - 1))->address == address)
965 locp_found--;
966
967 return locp_found;
968}
969
adc36818 970void
7a26bd4d 971set_breakpoint_condition (struct breakpoint *b, const char *exp,
adc36818
PM
972 int from_tty)
973{
3a5c3e22
PA
974 xfree (b->cond_string);
975 b->cond_string = NULL;
adc36818 976
3a5c3e22 977 if (is_watchpoint (b))
adc36818 978 {
3a5c3e22
PA
979 struct watchpoint *w = (struct watchpoint *) b;
980
981 xfree (w->cond_exp);
982 w->cond_exp = NULL;
983 }
984 else
985 {
986 struct bp_location *loc;
987
988 for (loc = b->loc; loc; loc = loc->next)
989 {
990 xfree (loc->cond);
991 loc->cond = NULL;
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
MS
1272breakpoint_set_commands (struct breakpoint *b,
1273 struct command_line *commands)
95a42b64
TT
1274{
1275 validate_commands_for_breakpoint (b, commands);
a7bdde9e 1276
9add0f1b
TT
1277 decref_counted_command_line (&b->commands);
1278 b->commands = alloc_counted_command_line (commands);
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
VP
1324{
1325 struct breakpoint *b = 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. */
1339 char *arg;
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{
95a42b64 1356 struct commands_info *info = data;
c906108c 1357
95a42b64
TT
1358 if (info->cmd == NULL)
1359 {
1360 struct command_line *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
95a42b64
TT
1384 info->cmd = alloc_counted_command_line (l);
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
4a64f543
MS
1400commands_command_1 (char *arg, int from_tty,
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
1413 if (arg == NULL || !*arg)
1414 {
86b17b60 1415 if (breakpoint_count - prev_breakpoint_count > 1)
4a64f543
MS
1416 arg = xstrprintf ("%d-%d", prev_breakpoint_count + 1,
1417 breakpoint_count);
95a42b64
TT
1418 else if (breakpoint_count > 0)
1419 arg = xstrprintf ("%d", breakpoint_count);
86b17b60
PA
1420 else
1421 {
1422 /* So that we don't try to free the incoming non-NULL
1423 argument in the cleanup below. Mapping breakpoint
1424 numbers will fail in this case. */
1425 arg = NULL;
1426 }
95a42b64 1427 }
9766ced4
SS
1428 else
1429 /* The command loop has some static state, so we need to preserve
1430 our argument. */
1431 arg = xstrdup (arg);
86b17b60
PA
1432
1433 if (arg != NULL)
1434 make_cleanup (xfree, arg);
1435
1436 info.arg = arg;
95a42b64
TT
1437
1438 map_breakpoint_numbers (arg, do_map_commands_command, &info);
1439
1440 if (info.cmd == NULL)
1441 error (_("No breakpoints specified."));
1442
1443 do_cleanups (cleanups);
1444}
1445
1446static void
1447commands_command (char *arg, int from_tty)
1448{
1449 commands_command_1 (arg, from_tty, NULL);
c906108c 1450}
40c03ae8
EZ
1451
1452/* Like commands_command, but instead of reading the commands from
1453 input stream, takes them from an already parsed command structure.
1454
1455 This is used by cli-script.c to DTRT with breakpoint commands
1456 that are part of if and while bodies. */
1457enum command_control_type
1458commands_from_control_command (char *arg, struct command_line *cmd)
1459{
95a42b64
TT
1460 commands_command_1 (arg, 0, cmd);
1461 return simple_control;
40c03ae8 1462}
876fa593
JK
1463
1464/* Return non-zero if BL->TARGET_INFO contains valid information. */
1465
1466static int
1467bp_location_has_shadow (struct bp_location *bl)
1468{
1469 if (bl->loc_type != bp_loc_software_breakpoint)
1470 return 0;
1471 if (!bl->inserted)
1472 return 0;
1473 if (bl->target_info.shadow_len == 0)
e5dd4106 1474 /* BL isn't valid, or doesn't shadow memory. */
876fa593
JK
1475 return 0;
1476 return 1;
1477}
1478
9d497a19
PA
1479/* Update BUF, which is LEN bytes read from the target address
1480 MEMADDR, by replacing a memory breakpoint with its shadowed
1481 contents.
1482
1483 If READBUF is not NULL, this buffer must not overlap with the of
1484 the breakpoint location's shadow_contents buffer. Otherwise, a
1485 failed assertion internal error will be raised. */
1486
1487static void
1488one_breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1489 const gdb_byte *writebuf_org,
1490 ULONGEST memaddr, LONGEST len,
1491 struct bp_target_info *target_info,
1492 struct gdbarch *gdbarch)
1493{
1494 /* Now do full processing of the found relevant range of elements. */
1495 CORE_ADDR bp_addr = 0;
1496 int bp_size = 0;
1497 int bptoffset = 0;
1498
1499 if (!breakpoint_address_match (target_info->placed_address_space, 0,
1500 current_program_space->aspace, 0))
1501 {
1502 /* The breakpoint is inserted in a different address space. */
1503 return;
1504 }
1505
1506 /* Addresses and length of the part of the breakpoint that
1507 we need to copy. */
1508 bp_addr = target_info->placed_address;
1509 bp_size = target_info->shadow_len;
1510
1511 if (bp_addr + bp_size <= memaddr)
1512 {
1513 /* The breakpoint is entirely before the chunk of memory we are
1514 reading. */
1515 return;
1516 }
1517
1518 if (bp_addr >= memaddr + len)
1519 {
1520 /* The breakpoint is entirely after the chunk of memory we are
1521 reading. */
1522 return;
1523 }
1524
1525 /* Offset within shadow_contents. */
1526 if (bp_addr < memaddr)
1527 {
1528 /* Only copy the second part of the breakpoint. */
1529 bp_size -= memaddr - bp_addr;
1530 bptoffset = memaddr - bp_addr;
1531 bp_addr = memaddr;
1532 }
1533
1534 if (bp_addr + bp_size > memaddr + len)
1535 {
1536 /* Only copy the first part of the breakpoint. */
1537 bp_size -= (bp_addr + bp_size) - (memaddr + len);
1538 }
1539
1540 if (readbuf != NULL)
1541 {
1542 /* Verify that the readbuf buffer does not overlap with the
1543 shadow_contents buffer. */
1544 gdb_assert (target_info->shadow_contents >= readbuf + len
1545 || readbuf >= (target_info->shadow_contents
1546 + target_info->shadow_len));
1547
1548 /* Update the read buffer with this inserted breakpoint's
1549 shadow. */
1550 memcpy (readbuf + bp_addr - memaddr,
1551 target_info->shadow_contents + bptoffset, bp_size);
1552 }
1553 else
1554 {
1555 const unsigned char *bp;
0d5ed153
MR
1556 CORE_ADDR addr = target_info->reqstd_address;
1557 int placed_size;
9d497a19
PA
1558
1559 /* Update the shadow with what we want to write to memory. */
1560 memcpy (target_info->shadow_contents + bptoffset,
1561 writebuf_org + bp_addr - memaddr, bp_size);
1562
1563 /* Determine appropriate breakpoint contents and size for this
1564 address. */
0d5ed153 1565 bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &placed_size);
9d497a19
PA
1566
1567 /* Update the final write buffer with this inserted
1568 breakpoint's INSN. */
1569 memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
1570 }
1571}
1572
8defab1a 1573/* Update BUF, which is LEN bytes read from the target address MEMADDR,
876fa593
JK
1574 by replacing any memory breakpoints with their shadowed contents.
1575
35c63cd8
JB
1576 If READBUF is not NULL, this buffer must not overlap with any of
1577 the breakpoint location's shadow_contents buffers. Otherwise,
1578 a failed assertion internal error will be raised.
1579
876fa593 1580 The range of shadowed area by each bp_location is:
35df4500
TJB
1581 bl->address - bp_location_placed_address_before_address_max
1582 up to bl->address + bp_location_shadow_len_after_address_max
876fa593
JK
1583 The range we were requested to resolve shadows for is:
1584 memaddr ... memaddr + len
1585 Thus the safe cutoff boundaries for performance optimization are
35df4500
TJB
1586 memaddr + len <= (bl->address
1587 - bp_location_placed_address_before_address_max)
876fa593 1588 and:
35df4500 1589 bl->address + bp_location_shadow_len_after_address_max <= memaddr */
c906108c 1590
8defab1a 1591void
f0ba3972
PA
1592breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1593 const gdb_byte *writebuf_org,
1594 ULONGEST memaddr, LONGEST len)
c906108c 1595{
4a64f543
MS
1596 /* Left boundary, right boundary and median element of our binary
1597 search. */
876fa593 1598 unsigned bc_l, bc_r, bc;
9d497a19 1599 size_t i;
876fa593 1600
4a64f543
MS
1601 /* Find BC_L which is a leftmost element which may affect BUF
1602 content. It is safe to report lower value but a failure to
1603 report higher one. */
876fa593
JK
1604
1605 bc_l = 0;
1606 bc_r = bp_location_count;
1607 while (bc_l + 1 < bc_r)
1608 {
35df4500 1609 struct bp_location *bl;
876fa593
JK
1610
1611 bc = (bc_l + bc_r) / 2;
35df4500 1612 bl = bp_location[bc];
876fa593 1613
4a64f543
MS
1614 /* Check first BL->ADDRESS will not overflow due to the added
1615 constant. Then advance the left boundary only if we are sure
1616 the BC element can in no way affect the BUF content (MEMADDR
1617 to MEMADDR + LEN range).
876fa593 1618
4a64f543
MS
1619 Use the BP_LOCATION_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1620 offset so that we cannot miss a breakpoint with its shadow
1621 range tail still reaching MEMADDR. */
c5aa993b 1622
35df4500
TJB
1623 if ((bl->address + bp_location_shadow_len_after_address_max
1624 >= bl->address)
1625 && (bl->address + bp_location_shadow_len_after_address_max
1626 <= memaddr))
876fa593
JK
1627 bc_l = bc;
1628 else
1629 bc_r = bc;
1630 }
1631
128070bb
PA
1632 /* Due to the binary search above, we need to make sure we pick the
1633 first location that's at BC_L's address. E.g., if there are
1634 multiple locations at the same address, BC_L may end up pointing
1635 at a duplicate location, and miss the "master"/"inserted"
1636 location. Say, given locations L1, L2 and L3 at addresses A and
1637 B:
1638
1639 L1@A, L2@A, L3@B, ...
1640
1641 BC_L could end up pointing at location L2, while the "master"
1642 location could be L1. Since the `loc->inserted' flag is only set
1643 on "master" locations, we'd forget to restore the shadow of L1
1644 and L2. */
1645 while (bc_l > 0
1646 && bp_location[bc_l]->address == bp_location[bc_l - 1]->address)
1647 bc_l--;
1648
876fa593
JK
1649 /* Now do full processing of the found relevant range of elements. */
1650
1651 for (bc = bc_l; bc < bp_location_count; bc++)
c5aa993b 1652 {
35df4500 1653 struct bp_location *bl = bp_location[bc];
876fa593
JK
1654 CORE_ADDR bp_addr = 0;
1655 int bp_size = 0;
1656 int bptoffset = 0;
1657
35df4500
TJB
1658 /* bp_location array has BL->OWNER always non-NULL. */
1659 if (bl->owner->type == bp_none)
8a3fe4f8 1660 warning (_("reading through apparently deleted breakpoint #%d?"),
35df4500 1661 bl->owner->number);
ffce0d52 1662
e5dd4106 1663 /* Performance optimization: any further element can no longer affect BUF
876fa593
JK
1664 content. */
1665
35df4500
TJB
1666 if (bl->address >= bp_location_placed_address_before_address_max
1667 && memaddr + len <= (bl->address
1668 - bp_location_placed_address_before_address_max))
876fa593
JK
1669 break;
1670
35df4500 1671 if (!bp_location_has_shadow (bl))
c5aa993b 1672 continue;
6c95b8df 1673
9d497a19
PA
1674 one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
1675 memaddr, len, &bl->target_info, bl->gdbarch);
1676 }
c906108c 1677}
9d497a19 1678
c906108c 1679\f
c5aa993b 1680
b775012e
LM
1681/* Return true if BPT is either a software breakpoint or a hardware
1682 breakpoint. */
1683
1684int
1685is_breakpoint (const struct breakpoint *bpt)
1686{
1687 return (bpt->type == bp_breakpoint
e7e0cddf
SS
1688 || bpt->type == bp_hardware_breakpoint
1689 || bpt->type == bp_dprintf);
b775012e
LM
1690}
1691
60e1c644
PA
1692/* Return true if BPT is of any hardware watchpoint kind. */
1693
a5606eee 1694static int
d77f58be 1695is_hardware_watchpoint (const struct breakpoint *bpt)
a5606eee
VP
1696{
1697 return (bpt->type == bp_hardware_watchpoint
1698 || bpt->type == bp_read_watchpoint
1699 || bpt->type == bp_access_watchpoint);
1700}
7270d8f2 1701
60e1c644
PA
1702/* Return true if BPT is of any watchpoint kind, hardware or
1703 software. */
1704
3a5c3e22 1705int
d77f58be 1706is_watchpoint (const struct breakpoint *bpt)
60e1c644
PA
1707{
1708 return (is_hardware_watchpoint (bpt)
1709 || bpt->type == bp_watchpoint);
1710}
1711
3a5c3e22
PA
1712/* Returns true if the current thread and its running state are safe
1713 to evaluate or update watchpoint B. Watchpoints on local
1714 expressions need to be evaluated in the context of the thread that
1715 was current when the watchpoint was created, and, that thread needs
1716 to be stopped to be able to select the correct frame context.
1717 Watchpoints on global expressions can be evaluated on any thread,
1718 and in any state. It is presently left to the target allowing
1719 memory accesses when threads are running. */
f6bc2008
PA
1720
1721static int
3a5c3e22 1722watchpoint_in_thread_scope (struct watchpoint *b)
f6bc2008 1723{
d0d8b0c6
JK
1724 return (b->base.pspace == current_program_space
1725 && (ptid_equal (b->watchpoint_thread, null_ptid)
1726 || (ptid_equal (inferior_ptid, b->watchpoint_thread)
1727 && !is_executing (inferior_ptid))));
f6bc2008
PA
1728}
1729
d0fb5eae
JK
1730/* Set watchpoint B to disp_del_at_next_stop, even including its possible
1731 associated bp_watchpoint_scope breakpoint. */
1732
1733static void
3a5c3e22 1734watchpoint_del_at_next_stop (struct watchpoint *w)
d0fb5eae 1735{
3a5c3e22 1736 struct breakpoint *b = &w->base;
d0fb5eae
JK
1737
1738 if (b->related_breakpoint != b)
1739 {
1740 gdb_assert (b->related_breakpoint->type == bp_watchpoint_scope);
1741 gdb_assert (b->related_breakpoint->related_breakpoint == b);
1742 b->related_breakpoint->disposition = disp_del_at_next_stop;
1743 b->related_breakpoint->related_breakpoint = b->related_breakpoint;
1744 b->related_breakpoint = b;
1745 }
1746 b->disposition = disp_del_at_next_stop;
1747}
1748
bb9d5f81
PP
1749/* Extract a bitfield value from value VAL using the bit parameters contained in
1750 watchpoint W. */
1751
1752static struct value *
1753extract_bitfield_from_watchpoint_value (struct watchpoint *w, struct value *val)
1754{
1755 struct value *bit_val;
1756
1757 if (val == NULL)
1758 return NULL;
1759
1760 bit_val = allocate_value (value_type (val));
1761
1762 unpack_value_bitfield (bit_val,
1763 w->val_bitpos,
1764 w->val_bitsize,
1765 value_contents_for_printing (val),
1766 value_offset (val),
1767 val);
1768
1769 return bit_val;
1770}
1771
567e1b4e
JB
1772/* Assuming that B is a watchpoint:
1773 - Reparse watchpoint expression, if REPARSE is non-zero
a5606eee 1774 - Evaluate expression and store the result in B->val
567e1b4e
JB
1775 - Evaluate the condition if there is one, and store the result
1776 in b->loc->cond.
a5606eee
VP
1777 - Update the list of values that must be watched in B->loc.
1778
4a64f543
MS
1779 If the watchpoint disposition is disp_del_at_next_stop, then do
1780 nothing. If this is local watchpoint that is out of scope, delete
1781 it.
1782
1783 Even with `set breakpoint always-inserted on' the watchpoints are
1784 removed + inserted on each stop here. Normal breakpoints must
1785 never be removed because they might be missed by a running thread
1786 when debugging in non-stop mode. On the other hand, hardware
1787 watchpoints (is_hardware_watchpoint; processed here) are specific
1788 to each LWP since they are stored in each LWP's hardware debug
1789 registers. Therefore, such LWP must be stopped first in order to
1790 be able to modify its hardware watchpoints.
1791
1792 Hardware watchpoints must be reset exactly once after being
1793 presented to the user. It cannot be done sooner, because it would
1794 reset the data used to present the watchpoint hit to the user. And
1795 it must not be done later because it could display the same single
1796 watchpoint hit during multiple GDB stops. Note that the latter is
1797 relevant only to the hardware watchpoint types bp_read_watchpoint
1798 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1799 not user-visible - its hit is suppressed if the memory content has
1800 not changed.
1801
1802 The following constraints influence the location where we can reset
1803 hardware watchpoints:
1804
1805 * target_stopped_by_watchpoint and target_stopped_data_address are
1806 called several times when GDB stops.
1807
1808 [linux]
1809 * Multiple hardware watchpoints can be hit at the same time,
1810 causing GDB to stop. GDB only presents one hardware watchpoint
1811 hit at a time as the reason for stopping, and all the other hits
1812 are presented later, one after the other, each time the user
1813 requests the execution to be resumed. Execution is not resumed
1814 for the threads still having pending hit event stored in
1815 LWP_INFO->STATUS. While the watchpoint is already removed from
1816 the inferior on the first stop the thread hit event is kept being
1817 reported from its cached value by linux_nat_stopped_data_address
1818 until the real thread resume happens after the watchpoint gets
1819 presented and thus its LWP_INFO->STATUS gets reset.
1820
1821 Therefore the hardware watchpoint hit can get safely reset on the
1822 watchpoint removal from inferior. */
a79d3c27 1823
b40ce68a 1824static void
3a5c3e22 1825update_watchpoint (struct watchpoint *b, int reparse)
7270d8f2 1826{
a5606eee 1827 int within_current_scope;
a5606eee 1828 struct frame_id saved_frame_id;
66076460 1829 int frame_saved;
a5606eee 1830
f6bc2008
PA
1831 /* If this is a local watchpoint, we only want to check if the
1832 watchpoint frame is in scope if the current thread is the thread
1833 that was used to create the watchpoint. */
1834 if (!watchpoint_in_thread_scope (b))
1835 return;
1836
3a5c3e22 1837 if (b->base.disposition == disp_del_at_next_stop)
a5606eee
VP
1838 return;
1839
66076460 1840 frame_saved = 0;
a5606eee
VP
1841
1842 /* Determine if the watchpoint is within scope. */
1843 if (b->exp_valid_block == NULL)
1844 within_current_scope = 1;
1845 else
1846 {
b5db5dfc
UW
1847 struct frame_info *fi = get_current_frame ();
1848 struct gdbarch *frame_arch = get_frame_arch (fi);
1849 CORE_ADDR frame_pc = get_frame_pc (fi);
1850
c9cf6e20
MG
1851 /* If we're at a point where the stack has been destroyed
1852 (e.g. in a function epilogue), unwinding may not work
1853 properly. Do not attempt to recreate locations at this
b5db5dfc 1854 point. See similar comments in watchpoint_check. */
c9cf6e20 1855 if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
b5db5dfc 1856 return;
66076460
DJ
1857
1858 /* Save the current frame's ID so we can restore it after
1859 evaluating the watchpoint expression on its own frame. */
1860 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1861 took a frame parameter, so that we didn't have to change the
1862 selected frame. */
1863 frame_saved = 1;
1864 saved_frame_id = get_frame_id (get_selected_frame (NULL));
1865
a5606eee
VP
1866 fi = frame_find_by_id (b->watchpoint_frame);
1867 within_current_scope = (fi != NULL);
1868 if (within_current_scope)
1869 select_frame (fi);
1870 }
1871
b5db5dfc
UW
1872 /* We don't free locations. They are stored in the bp_location array
1873 and update_global_location_list will eventually delete them and
1874 remove breakpoints if needed. */
3a5c3e22 1875 b->base.loc = NULL;
b5db5dfc 1876
a5606eee
VP
1877 if (within_current_scope && reparse)
1878 {
bbc13ae3 1879 const char *s;
d63d0675 1880
a5606eee
VP
1881 if (b->exp)
1882 {
1883 xfree (b->exp);
1884 b->exp = NULL;
1885 }
d63d0675 1886 s = b->exp_string_reparse ? b->exp_string_reparse : b->exp_string;
1bb9788d 1887 b->exp = parse_exp_1 (&s, 0, b->exp_valid_block, 0);
a5606eee
VP
1888 /* If the meaning of expression itself changed, the old value is
1889 no longer relevant. We don't want to report a watchpoint hit
1890 to the user when the old value and the new value may actually
1891 be completely different objects. */
1892 value_free (b->val);
fa4727a6
DJ
1893 b->val = NULL;
1894 b->val_valid = 0;
60e1c644
PA
1895
1896 /* Note that unlike with breakpoints, the watchpoint's condition
1897 expression is stored in the breakpoint object, not in the
1898 locations (re)created below. */
3a5c3e22 1899 if (b->base.cond_string != NULL)
60e1c644
PA
1900 {
1901 if (b->cond_exp != NULL)
1902 {
1903 xfree (b->cond_exp);
1904 b->cond_exp = NULL;
1905 }
1906
3a5c3e22 1907 s = b->base.cond_string;
1bb9788d 1908 b->cond_exp = parse_exp_1 (&s, 0, b->cond_exp_valid_block, 0);
60e1c644 1909 }
a5606eee 1910 }
a5606eee
VP
1911
1912 /* If we failed to parse the expression, for example because
1913 it refers to a global variable in a not-yet-loaded shared library,
1914 don't try to insert watchpoint. We don't automatically delete
1915 such watchpoint, though, since failure to parse expression
1916 is different from out-of-scope watchpoint. */
e8369a73 1917 if (!target_has_execution)
2d134ed3
PA
1918 {
1919 /* Without execution, memory can't change. No use to try and
1920 set watchpoint locations. The watchpoint will be reset when
1921 the target gains execution, through breakpoint_re_set. */
e8369a73
AB
1922 if (!can_use_hw_watchpoints)
1923 {
1924 if (b->base.ops->works_in_software_mode (&b->base))
1925 b->base.type = bp_watchpoint;
1926 else
638aa5a1
AB
1927 error (_("Can't set read/access watchpoint when "
1928 "hardware watchpoints are disabled."));
e8369a73 1929 }
2d134ed3
PA
1930 }
1931 else if (within_current_scope && b->exp)
a5606eee 1932 {
0cf6dd15 1933 int pc = 0;
fa4727a6 1934 struct value *val_chain, *v, *result, *next;
2d134ed3 1935 struct program_space *frame_pspace;
a5606eee 1936
3a1115a0 1937 fetch_subexp_value (b->exp, &pc, &v, &result, &val_chain, 0);
a5606eee 1938
a5606eee
VP
1939 /* Avoid setting b->val if it's already set. The meaning of
1940 b->val is 'the last value' user saw, and we should update
1941 it only if we reported that last value to user. As it
9c06b0b4
TJB
1942 happens, the code that reports it updates b->val directly.
1943 We don't keep track of the memory value for masked
1944 watchpoints. */
3a5c3e22 1945 if (!b->val_valid && !is_masked_watchpoint (&b->base))
fa4727a6 1946 {
bb9d5f81
PP
1947 if (b->val_bitsize != 0)
1948 {
1949 v = extract_bitfield_from_watchpoint_value (b, v);
1950 if (v != NULL)
1951 release_value (v);
1952 }
fa4727a6
DJ
1953 b->val = v;
1954 b->val_valid = 1;
1955 }
a5606eee 1956
2d134ed3
PA
1957 frame_pspace = get_frame_program_space (get_selected_frame (NULL));
1958
a5606eee 1959 /* Look at each value on the value chain. */
9fa40276 1960 for (v = val_chain; v; v = value_next (v))
a5606eee
VP
1961 {
1962 /* If it's a memory location, and GDB actually needed
1963 its contents to evaluate the expression, then we
fa4727a6
DJ
1964 must watch it. If the first value returned is
1965 still lazy, that means an error occurred reading it;
1966 watch it anyway in case it becomes readable. */
a5606eee 1967 if (VALUE_LVAL (v) == lval_memory
fa4727a6 1968 && (v == val_chain || ! value_lazy (v)))
a5606eee
VP
1969 {
1970 struct type *vtype = check_typedef (value_type (v));
7270d8f2 1971
a5606eee
VP
1972 /* We only watch structs and arrays if user asked
1973 for it explicitly, never if they just happen to
1974 appear in the middle of some value chain. */
fa4727a6 1975 if (v == result
a5606eee
VP
1976 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1977 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1978 {
1979 CORE_ADDR addr;
f486487f 1980 enum target_hw_bp_type type;
a5606eee 1981 struct bp_location *loc, **tmp;
bb9d5f81
PP
1982 int bitpos = 0, bitsize = 0;
1983
1984 if (value_bitsize (v) != 0)
1985 {
1986 /* Extract the bit parameters out from the bitfield
1987 sub-expression. */
1988 bitpos = value_bitpos (v);
1989 bitsize = value_bitsize (v);
1990 }
1991 else if (v == result && b->val_bitsize != 0)
1992 {
1993 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1994 lvalue whose bit parameters are saved in the fields
1995 VAL_BITPOS and VAL_BITSIZE. */
1996 bitpos = b->val_bitpos;
1997 bitsize = b->val_bitsize;
1998 }
a5606eee 1999
42ae5230 2000 addr = value_address (v);
bb9d5f81
PP
2001 if (bitsize != 0)
2002 {
2003 /* Skip the bytes that don't contain the bitfield. */
2004 addr += bitpos / 8;
2005 }
2006
a5606eee 2007 type = hw_write;
3a5c3e22 2008 if (b->base.type == bp_read_watchpoint)
a5606eee 2009 type = hw_read;
3a5c3e22 2010 else if (b->base.type == bp_access_watchpoint)
a5606eee 2011 type = hw_access;
3a5c3e22
PA
2012
2013 loc = allocate_bp_location (&b->base);
2014 for (tmp = &(b->base.loc); *tmp != NULL; tmp = &((*tmp)->next))
a5606eee
VP
2015 ;
2016 *tmp = loc;
a6d9a66e 2017 loc->gdbarch = get_type_arch (value_type (v));
6c95b8df
PA
2018
2019 loc->pspace = frame_pspace;
a5606eee 2020 loc->address = addr;
bb9d5f81
PP
2021
2022 if (bitsize != 0)
2023 {
2024 /* Just cover the bytes that make up the bitfield. */
2025 loc->length = ((bitpos % 8) + bitsize + 7) / 8;
2026 }
2027 else
2028 loc->length = TYPE_LENGTH (value_type (v));
2029
a5606eee
VP
2030 loc->watchpoint_type = type;
2031 }
2032 }
9fa40276
TJB
2033 }
2034
2035 /* Change the type of breakpoint between hardware assisted or
2036 an ordinary watchpoint depending on the hardware support
2037 and free hardware slots. REPARSE is set when the inferior
2038 is started. */
a9634178 2039 if (reparse)
9fa40276 2040 {
e09342b5 2041 int reg_cnt;
9fa40276
TJB
2042 enum bp_loc_type loc_type;
2043 struct bp_location *bl;
a5606eee 2044
a9634178 2045 reg_cnt = can_use_hardware_watchpoint (val_chain);
e09342b5
TJB
2046
2047 if (reg_cnt)
9fa40276
TJB
2048 {
2049 int i, target_resources_ok, other_type_used;
a1398e0c 2050 enum bptype type;
9fa40276 2051
a9634178
TJB
2052 /* Use an exact watchpoint when there's only one memory region to be
2053 watched, and only one debug register is needed to watch it. */
2054 b->exact = target_exact_watchpoints && reg_cnt == 1;
2055
9fa40276 2056 /* We need to determine how many resources are already
e09342b5
TJB
2057 used for all other hardware watchpoints plus this one
2058 to see if we still have enough resources to also fit
a1398e0c
PA
2059 this watchpoint in as well. */
2060
2061 /* If this is a software watchpoint, we try to turn it
2062 to a hardware one -- count resources as if B was of
2063 hardware watchpoint type. */
2064 type = b->base.type;
2065 if (type == bp_watchpoint)
2066 type = bp_hardware_watchpoint;
2067
2068 /* This watchpoint may or may not have been placed on
2069 the list yet at this point (it won't be in the list
2070 if we're trying to create it for the first time,
2071 through watch_command), so always account for it
2072 manually. */
2073
2074 /* Count resources used by all watchpoints except B. */
2075 i = hw_watchpoint_used_count_others (&b->base, type, &other_type_used);
2076
2077 /* Add in the resources needed for B. */
2078 i += hw_watchpoint_use_count (&b->base);
2079
2080 target_resources_ok
2081 = target_can_use_hardware_watchpoint (type, i, other_type_used);
e09342b5 2082 if (target_resources_ok <= 0)
a9634178 2083 {
3a5c3e22 2084 int sw_mode = b->base.ops->works_in_software_mode (&b->base);
9c06b0b4
TJB
2085
2086 if (target_resources_ok == 0 && !sw_mode)
a9634178
TJB
2087 error (_("Target does not support this type of "
2088 "hardware watchpoint."));
9c06b0b4
TJB
2089 else if (target_resources_ok < 0 && !sw_mode)
2090 error (_("There are not enough available hardware "
2091 "resources for this watchpoint."));
a1398e0c
PA
2092
2093 /* Downgrade to software watchpoint. */
2094 b->base.type = bp_watchpoint;
2095 }
2096 else
2097 {
2098 /* If this was a software watchpoint, we've just
2099 found we have enough resources to turn it to a
2100 hardware watchpoint. Otherwise, this is a
2101 nop. */
2102 b->base.type = type;
a9634178 2103 }
9fa40276 2104 }
3a5c3e22 2105 else if (!b->base.ops->works_in_software_mode (&b->base))
638aa5a1
AB
2106 {
2107 if (!can_use_hw_watchpoints)
2108 error (_("Can't set read/access watchpoint when "
2109 "hardware watchpoints are disabled."));
2110 else
2111 error (_("Expression cannot be implemented with "
2112 "read/access watchpoint."));
2113 }
9fa40276 2114 else
3a5c3e22 2115 b->base.type = bp_watchpoint;
9fa40276 2116
3a5c3e22 2117 loc_type = (b->base.type == bp_watchpoint? bp_loc_other
9fa40276 2118 : bp_loc_hardware_watchpoint);
3a5c3e22 2119 for (bl = b->base.loc; bl; bl = bl->next)
9fa40276
TJB
2120 bl->loc_type = loc_type;
2121 }
2122
2123 for (v = val_chain; v; v = next)
2124 {
a5606eee
VP
2125 next = value_next (v);
2126 if (v != b->val)
2127 value_free (v);
2128 }
2129
c7437ca6
PA
2130 /* If a software watchpoint is not watching any memory, then the
2131 above left it without any location set up. But,
2132 bpstat_stop_status requires a location to be able to report
2133 stops, so make sure there's at least a dummy one. */
3a5c3e22 2134 if (b->base.type == bp_watchpoint && b->base.loc == NULL)
c7437ca6 2135 {
3a5c3e22
PA
2136 struct breakpoint *base = &b->base;
2137 base->loc = allocate_bp_location (base);
2138 base->loc->pspace = frame_pspace;
2139 base->loc->address = -1;
2140 base->loc->length = -1;
2141 base->loc->watchpoint_type = -1;
c7437ca6 2142 }
a5606eee
VP
2143 }
2144 else if (!within_current_scope)
7270d8f2 2145 {
ac74f770
MS
2146 printf_filtered (_("\
2147Watchpoint %d deleted because the program has left the block\n\
2148in which its expression is valid.\n"),
3a5c3e22 2149 b->base.number);
d0fb5eae 2150 watchpoint_del_at_next_stop (b);
7270d8f2 2151 }
a5606eee
VP
2152
2153 /* Restore the selected frame. */
66076460
DJ
2154 if (frame_saved)
2155 select_frame (frame_find_by_id (saved_frame_id));
7270d8f2
OF
2156}
2157
a5606eee 2158
74960c60 2159/* Returns 1 iff breakpoint location should be
1e4d1764
YQ
2160 inserted in the inferior. We don't differentiate the type of BL's owner
2161 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2162 breakpoint_ops is not defined, because in insert_bp_location,
2163 tracepoint's insert_location will not be called. */
74960c60 2164static int
35df4500 2165should_be_inserted (struct bp_location *bl)
74960c60 2166{
35df4500 2167 if (bl->owner == NULL || !breakpoint_enabled (bl->owner))
74960c60
VP
2168 return 0;
2169
35df4500 2170 if (bl->owner->disposition == disp_del_at_next_stop)
74960c60
VP
2171 return 0;
2172
35df4500 2173 if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
74960c60
VP
2174 return 0;
2175
f8eba3c6
TT
2176 if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
2177 return 0;
2178
56710373
PA
2179 /* This is set for example, when we're attached to the parent of a
2180 vfork, and have detached from the child. The child is running
2181 free, and we expect it to do an exec or exit, at which point the
2182 OS makes the parent schedulable again (and the target reports
2183 that the vfork is done). Until the child is done with the shared
2184 memory region, do not insert breakpoints in the parent, otherwise
2185 the child could still trip on the parent's breakpoints. Since
2186 the parent is blocked anyway, it won't miss any breakpoint. */
35df4500 2187 if (bl->pspace->breakpoints_not_allowed)
56710373
PA
2188 return 0;
2189
31e77af2
PA
2190 /* Don't insert a breakpoint if we're trying to step past its
2191 location. */
2192 if ((bl->loc_type == bp_loc_software_breakpoint
2193 || bl->loc_type == bp_loc_hardware_breakpoint)
2194 && stepping_past_instruction_at (bl->pspace->aspace,
2195 bl->address))
e558d7c1
PA
2196 {
2197 if (debug_infrun)
2198 {
2199 fprintf_unfiltered (gdb_stdlog,
2200 "infrun: skipping breakpoint: "
2201 "stepping past insn at: %s\n",
2202 paddress (bl->gdbarch, bl->address));
2203 }
2204 return 0;
2205 }
31e77af2 2206
963f9c80
PA
2207 /* Don't insert watchpoints if we're trying to step past the
2208 instruction that triggered one. */
2209 if ((bl->loc_type == bp_loc_hardware_watchpoint)
2210 && stepping_past_nonsteppable_watchpoint ())
2211 {
2212 if (debug_infrun)
2213 {
2214 fprintf_unfiltered (gdb_stdlog,
2215 "infrun: stepping past non-steppable watchpoint. "
2216 "skipping watchpoint at %s:%d\n",
2217 paddress (bl->gdbarch, bl->address),
2218 bl->length);
2219 }
2220 return 0;
2221 }
2222
74960c60
VP
2223 return 1;
2224}
2225
934709f0
PW
2226/* Same as should_be_inserted but does the check assuming
2227 that the location is not duplicated. */
2228
2229static int
2230unduplicated_should_be_inserted (struct bp_location *bl)
2231{
2232 int result;
2233 const int save_duplicate = bl->duplicate;
2234
2235 bl->duplicate = 0;
2236 result = should_be_inserted (bl);
2237 bl->duplicate = save_duplicate;
2238 return result;
2239}
2240
b775012e
LM
2241/* Parses a conditional described by an expression COND into an
2242 agent expression bytecode suitable for evaluation
2243 by the bytecode interpreter. Return NULL if there was
2244 any error during parsing. */
2245
2246static struct agent_expr *
2247parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
2248{
2249 struct agent_expr *aexpr = NULL;
b775012e
LM
2250
2251 if (!cond)
2252 return NULL;
2253
2254 /* We don't want to stop processing, so catch any errors
2255 that may show up. */
492d29ea 2256 TRY
b775012e
LM
2257 {
2258 aexpr = gen_eval_for_expr (scope, cond);
2259 }
2260
492d29ea 2261 CATCH (ex, RETURN_MASK_ERROR)
b775012e
LM
2262 {
2263 /* If we got here, it means the condition could not be parsed to a valid
2264 bytecode expression and thus can't be evaluated on the target's side.
2265 It's no use iterating through the conditions. */
2266 return NULL;
2267 }
492d29ea 2268 END_CATCH
b775012e
LM
2269
2270 /* We have a valid agent expression. */
2271 return aexpr;
2272}
2273
2274/* Based on location BL, create a list of breakpoint conditions to be
2275 passed on to the target. If we have duplicated locations with different
2276 conditions, we will add such conditions to the list. The idea is that the
2277 target will evaluate the list of conditions and will only notify GDB when
2278 one of them is true. */
2279
2280static void
2281build_target_condition_list (struct bp_location *bl)
2282{
2283 struct bp_location **locp = NULL, **loc2p;
2284 int null_condition_or_parse_error = 0;
2285 int modified = bl->needs_update;
2286 struct bp_location *loc;
2287
8b4f3082
PA
2288 /* Release conditions left over from a previous insert. */
2289 VEC_free (agent_expr_p, bl->target_info.conditions);
2290
b775012e
LM
2291 /* This is only meaningful if the target is
2292 evaluating conditions and if the user has
2293 opted for condition evaluation on the target's
2294 side. */
2295 if (gdb_evaluates_breakpoint_condition_p ()
2296 || !target_supports_evaluation_of_breakpoint_conditions ())
2297 return;
2298
2299 /* Do a first pass to check for locations with no assigned
2300 conditions or conditions that fail to parse to a valid agent expression
2301 bytecode. If any of these happen, then it's no use to send conditions
2302 to the target since this location will always trigger and generate a
2303 response back to GDB. */
2304 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2305 {
2306 loc = (*loc2p);
2307 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2308 {
2309 if (modified)
2310 {
2311 struct agent_expr *aexpr;
2312
2313 /* Re-parse the conditions since something changed. In that
2314 case we already freed the condition bytecodes (see
2315 force_breakpoint_reinsertion). We just
2316 need to parse the condition to bytecodes again. */
2317 aexpr = parse_cond_to_aexpr (bl->address, loc->cond);
2318 loc->cond_bytecode = aexpr;
2319
2320 /* Check if we managed to parse the conditional expression
2321 correctly. If not, we will not send this condition
2322 to the target. */
2323 if (aexpr)
2324 continue;
2325 }
2326
2327 /* If we have a NULL bytecode expression, it means something
2328 went wrong or we have a null condition expression. */
2329 if (!loc->cond_bytecode)
2330 {
2331 null_condition_or_parse_error = 1;
2332 break;
2333 }
2334 }
2335 }
2336
2337 /* If any of these happened, it means we will have to evaluate the conditions
2338 for the location's address on gdb's side. It is no use keeping bytecodes
2339 for all the other duplicate locations, thus we free all of them here.
2340
2341 This is so we have a finer control over which locations' conditions are
2342 being evaluated by GDB or the remote stub. */
2343 if (null_condition_or_parse_error)
2344 {
2345 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2346 {
2347 loc = (*loc2p);
2348 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2349 {
2350 /* Only go as far as the first NULL bytecode is
2351 located. */
2352 if (!loc->cond_bytecode)
2353 return;
2354
2355 free_agent_expr (loc->cond_bytecode);
2356 loc->cond_bytecode = NULL;
2357 }
2358 }
2359 }
2360
2361 /* No NULL conditions or failed bytecode generation. Build a condition list
2362 for this location's address. */
2363 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2364 {
2365 loc = (*loc2p);
2366 if (loc->cond
2367 && is_breakpoint (loc->owner)
2368 && loc->pspace->num == bl->pspace->num
2369 && loc->owner->enable_state == bp_enabled
2370 && loc->enabled)
2371 /* Add the condition to the vector. This will be used later to send the
2372 conditions to the target. */
2373 VEC_safe_push (agent_expr_p, bl->target_info.conditions,
2374 loc->cond_bytecode);
2375 }
2376
2377 return;
2378}
2379
d3ce09f5
SS
2380/* Parses a command described by string CMD into an agent expression
2381 bytecode suitable for evaluation by the bytecode interpreter.
2382 Return NULL if there was any error during parsing. */
2383
2384static struct agent_expr *
2385parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
2386{
2387 struct cleanup *old_cleanups = 0;
2388 struct expression *expr, **argvec;
2389 struct agent_expr *aexpr = NULL;
bbc13ae3
KS
2390 const char *cmdrest;
2391 const char *format_start, *format_end;
d3ce09f5
SS
2392 struct format_piece *fpieces;
2393 int nargs;
2394 struct gdbarch *gdbarch = get_current_arch ();
2395
2396 if (!cmd)
2397 return NULL;
2398
2399 cmdrest = cmd;
2400
2401 if (*cmdrest == ',')
2402 ++cmdrest;
bbc13ae3 2403 cmdrest = skip_spaces_const (cmdrest);
d3ce09f5
SS
2404
2405 if (*cmdrest++ != '"')
2406 error (_("No format string following the location"));
2407
2408 format_start = cmdrest;
2409
2410 fpieces = parse_format_string (&cmdrest);
2411
2412 old_cleanups = make_cleanup (free_format_pieces_cleanup, &fpieces);
2413
2414 format_end = cmdrest;
2415
2416 if (*cmdrest++ != '"')
2417 error (_("Bad format string, non-terminated '\"'."));
2418
bbc13ae3 2419 cmdrest = skip_spaces_const (cmdrest);
d3ce09f5
SS
2420
2421 if (!(*cmdrest == ',' || *cmdrest == '\0'))
2422 error (_("Invalid argument syntax"));
2423
2424 if (*cmdrest == ',')
2425 cmdrest++;
bbc13ae3 2426 cmdrest = skip_spaces_const (cmdrest);
d3ce09f5
SS
2427
2428 /* For each argument, make an expression. */
2429
2430 argvec = (struct expression **) alloca (strlen (cmd)
2431 * sizeof (struct expression *));
2432
2433 nargs = 0;
2434 while (*cmdrest != '\0')
2435 {
bbc13ae3 2436 const char *cmd1;
d3ce09f5
SS
2437
2438 cmd1 = cmdrest;
2439 expr = parse_exp_1 (&cmd1, scope, block_for_pc (scope), 1);
2440 argvec[nargs++] = expr;
2441 cmdrest = cmd1;
2442 if (*cmdrest == ',')
2443 ++cmdrest;
2444 }
2445
2446 /* We don't want to stop processing, so catch any errors
2447 that may show up. */
492d29ea 2448 TRY
d3ce09f5
SS
2449 {
2450 aexpr = gen_printf (scope, gdbarch, 0, 0,
2451 format_start, format_end - format_start,
2452 fpieces, nargs, argvec);
2453 }
492d29ea 2454 CATCH (ex, RETURN_MASK_ERROR)
d3ce09f5
SS
2455 {
2456 /* If we got here, it means the command could not be parsed to a valid
2457 bytecode expression and thus can't be evaluated on the target's side.
2458 It's no use iterating through the other commands. */
492d29ea 2459 aexpr = NULL;
d3ce09f5 2460 }
492d29ea
PA
2461 END_CATCH
2462
2463 do_cleanups (old_cleanups);
d3ce09f5 2464
d3ce09f5
SS
2465 /* We have a valid agent expression, return it. */
2466 return aexpr;
2467}
2468
2469/* Based on location BL, create a list of breakpoint commands to be
2470 passed on to the target. If we have duplicated locations with
2471 different commands, we will add any such to the list. */
2472
2473static void
2474build_target_command_list (struct bp_location *bl)
2475{
2476 struct bp_location **locp = NULL, **loc2p;
2477 int null_command_or_parse_error = 0;
2478 int modified = bl->needs_update;
2479 struct bp_location *loc;
2480
8b4f3082
PA
2481 /* Release commands left over from a previous insert. */
2482 VEC_free (agent_expr_p, bl->target_info.tcommands);
2483
41fac0cf 2484 if (!target_can_run_breakpoint_commands ())
d3ce09f5
SS
2485 return;
2486
41fac0cf
PA
2487 /* For now, limit to agent-style dprintf breakpoints. */
2488 if (dprintf_style != dprintf_style_agent)
d3ce09f5
SS
2489 return;
2490
41fac0cf
PA
2491 /* For now, if we have any duplicate location that isn't a dprintf,
2492 don't install the target-side commands, as that would make the
2493 breakpoint not be reported to the core, and we'd lose
2494 control. */
2495 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2496 {
2497 loc = (*loc2p);
2498 if (is_breakpoint (loc->owner)
2499 && loc->pspace->num == bl->pspace->num
2500 && loc->owner->type != bp_dprintf)
2501 return;
2502 }
2503
d3ce09f5
SS
2504 /* Do a first pass to check for locations with no assigned
2505 conditions or conditions that fail to parse to a valid agent expression
2506 bytecode. If any of these happen, then it's no use to send conditions
2507 to the target since this location will always trigger and generate a
2508 response back to GDB. */
2509 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2510 {
2511 loc = (*loc2p);
2512 if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
2513 {
2514 if (modified)
2515 {
2516 struct agent_expr *aexpr;
2517
2518 /* Re-parse the commands since something changed. In that
2519 case we already freed the command bytecodes (see
2520 force_breakpoint_reinsertion). We just
2521 need to parse the command to bytecodes again. */
2522 aexpr = parse_cmd_to_aexpr (bl->address,
2523 loc->owner->extra_string);
2524 loc->cmd_bytecode = aexpr;
2525
2526 if (!aexpr)
2527 continue;
2528 }
2529
2530 /* If we have a NULL bytecode expression, it means something
2531 went wrong or we have a null command expression. */
2532 if (!loc->cmd_bytecode)
2533 {
2534 null_command_or_parse_error = 1;
2535 break;
2536 }
2537 }
2538 }
2539
2540 /* If anything failed, then we're not doing target-side commands,
2541 and so clean up. */
2542 if (null_command_or_parse_error)
2543 {
2544 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2545 {
2546 loc = (*loc2p);
2547 if (is_breakpoint (loc->owner)
2548 && loc->pspace->num == bl->pspace->num)
2549 {
2550 /* Only go as far as the first NULL bytecode is
2551 located. */
40fb6c5e 2552 if (loc->cmd_bytecode == NULL)
d3ce09f5
SS
2553 return;
2554
40fb6c5e
HZ
2555 free_agent_expr (loc->cmd_bytecode);
2556 loc->cmd_bytecode = NULL;
d3ce09f5
SS
2557 }
2558 }
2559 }
2560
2561 /* No NULL commands or failed bytecode generation. Build a command list
2562 for this location's address. */
2563 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
2564 {
2565 loc = (*loc2p);
2566 if (loc->owner->extra_string
2567 && is_breakpoint (loc->owner)
2568 && loc->pspace->num == bl->pspace->num
2569 && loc->owner->enable_state == bp_enabled
2570 && loc->enabled)
2571 /* Add the command to the vector. This will be used later
2572 to send the commands to the target. */
2573 VEC_safe_push (agent_expr_p, bl->target_info.tcommands,
2574 loc->cmd_bytecode);
2575 }
2576
2577 bl->target_info.persist = 0;
2578 /* Maybe flag this location as persistent. */
2579 if (bl->owner->type == bp_dprintf && disconnected_dprintf)
2580 bl->target_info.persist = 1;
2581}
2582
35df4500
TJB
2583/* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2584 location. Any error messages are printed to TMP_ERROR_STREAM; and
3fbb6ffa 2585 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
c30eee59
TJB
2586 Returns 0 for success, 1 if the bp_location type is not supported or
2587 -1 for failure.
879bfdc2 2588
4a64f543
MS
2589 NOTE drow/2003-09-09: This routine could be broken down to an
2590 object-style method for each breakpoint or catchpoint type. */
26bb91f3 2591static int
35df4500 2592insert_bp_location (struct bp_location *bl,
26bb91f3 2593 struct ui_file *tmp_error_stream,
3fbb6ffa 2594 int *disabled_breaks,
dd61ec5c
MW
2595 int *hw_breakpoint_error,
2596 int *hw_bp_error_explained_already)
879bfdc2 2597{
0000e5cc
PA
2598 enum errors bp_err = GDB_NO_ERROR;
2599 const char *bp_err_message = NULL;
879bfdc2 2600
b775012e 2601 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
879bfdc2
DJ
2602 return 0;
2603
35c63cd8
JB
2604 /* Note we don't initialize bl->target_info, as that wipes out
2605 the breakpoint location's shadow_contents if the breakpoint
2606 is still inserted at that location. This in turn breaks
2607 target_read_memory which depends on these buffers when
2608 a memory read is requested at the breakpoint location:
2609 Once the target_info has been wiped, we fail to see that
2610 we have a breakpoint inserted at that address and thus
2611 read the breakpoint instead of returning the data saved in
2612 the breakpoint location's shadow contents. */
0d5ed153 2613 bl->target_info.reqstd_address = bl->address;
35df4500 2614 bl->target_info.placed_address_space = bl->pspace->aspace;
f1310107 2615 bl->target_info.length = bl->length;
8181d85f 2616
b775012e
LM
2617 /* When working with target-side conditions, we must pass all the conditions
2618 for the same breakpoint address down to the target since GDB will not
2619 insert those locations. With a list of breakpoint conditions, the target
2620 can decide when to stop and notify GDB. */
2621
2622 if (is_breakpoint (bl->owner))
2623 {
2624 build_target_condition_list (bl);
d3ce09f5
SS
2625 build_target_command_list (bl);
2626 /* Reset the modification marker. */
b775012e
LM
2627 bl->needs_update = 0;
2628 }
2629
35df4500
TJB
2630 if (bl->loc_type == bp_loc_software_breakpoint
2631 || bl->loc_type == bp_loc_hardware_breakpoint)
879bfdc2 2632 {
35df4500 2633 if (bl->owner->type != bp_hardware_breakpoint)
765dc015
VP
2634 {
2635 /* If the explicitly specified breakpoint type
2636 is not hardware breakpoint, check the memory map to see
2637 if the breakpoint address is in read only memory or not.
4a64f543 2638
765dc015
VP
2639 Two important cases are:
2640 - location type is not hardware breakpoint, memory
2641 is readonly. We change the type of the location to
2642 hardware breakpoint.
4a64f543
MS
2643 - location type is hardware breakpoint, memory is
2644 read-write. This means we've previously made the
2645 location hardware one, but then the memory map changed,
2646 so we undo.
765dc015 2647
4a64f543
MS
2648 When breakpoints are removed, remove_breakpoints will use
2649 location types we've just set here, the only possible
2650 problem is that memory map has changed during running
2651 program, but it's not going to work anyway with current
2652 gdb. */
765dc015 2653 struct mem_region *mr
0d5ed153 2654 = lookup_mem_region (bl->target_info.reqstd_address);
765dc015
VP
2655
2656 if (mr)
2657 {
2658 if (automatic_hardware_breakpoints)
2659 {
765dc015
VP
2660 enum bp_loc_type new_type;
2661
2662 if (mr->attrib.mode != MEM_RW)
2663 new_type = bp_loc_hardware_breakpoint;
2664 else
2665 new_type = bp_loc_software_breakpoint;
2666
35df4500 2667 if (new_type != bl->loc_type)
765dc015
VP
2668 {
2669 static int said = 0;
cc59ec59 2670
35df4500 2671 bl->loc_type = new_type;
765dc015
VP
2672 if (!said)
2673 {
3e43a32a
MS
2674 fprintf_filtered (gdb_stdout,
2675 _("Note: automatically using "
2676 "hardware breakpoints for "
2677 "read-only addresses.\n"));
765dc015
VP
2678 said = 1;
2679 }
2680 }
2681 }
35df4500 2682 else if (bl->loc_type == bp_loc_software_breakpoint
0fec99e8
PA
2683 && mr->attrib.mode != MEM_RW)
2684 {
2685 fprintf_unfiltered (tmp_error_stream,
2686 _("Cannot insert breakpoint %d.\n"
2687 "Cannot set software breakpoint "
2688 "at read-only address %s\n"),
2689 bl->owner->number,
2690 paddress (bl->gdbarch, bl->address));
2691 return 1;
2692 }
765dc015
VP
2693 }
2694 }
2695
879bfdc2
DJ
2696 /* First check to see if we have to handle an overlay. */
2697 if (overlay_debugging == ovly_off
35df4500
TJB
2698 || bl->section == NULL
2699 || !(section_is_overlay (bl->section)))
879bfdc2
DJ
2700 {
2701 /* No overlay handling: just set the breakpoint. */
492d29ea 2702 TRY
dd61ec5c 2703 {
0000e5cc
PA
2704 int val;
2705
dd61ec5c 2706 val = bl->owner->ops->insert_location (bl);
0000e5cc
PA
2707 if (val)
2708 bp_err = GENERIC_ERROR;
dd61ec5c 2709 }
492d29ea 2710 CATCH (e, RETURN_MASK_ALL)
dd61ec5c 2711 {
0000e5cc
PA
2712 bp_err = e.error;
2713 bp_err_message = e.message;
dd61ec5c 2714 }
492d29ea 2715 END_CATCH
879bfdc2
DJ
2716 }
2717 else
2718 {
4a64f543 2719 /* This breakpoint is in an overlay section.
879bfdc2
DJ
2720 Shall we set a breakpoint at the LMA? */
2721 if (!overlay_events_enabled)
2722 {
2723 /* Yes -- overlay event support is not active,
2724 so we must try to set a breakpoint at the LMA.
2725 This will not work for a hardware breakpoint. */
35df4500 2726 if (bl->loc_type == bp_loc_hardware_breakpoint)
8a3fe4f8 2727 warning (_("hardware breakpoint %d not supported in overlay!"),
35df4500 2728 bl->owner->number);
879bfdc2
DJ
2729 else
2730 {
35df4500
TJB
2731 CORE_ADDR addr = overlay_unmapped_address (bl->address,
2732 bl->section);
879bfdc2 2733 /* Set a software (trap) breakpoint at the LMA. */
35df4500 2734 bl->overlay_target_info = bl->target_info;
0d5ed153 2735 bl->overlay_target_info.reqstd_address = addr;
0000e5cc
PA
2736
2737 /* No overlay handling: just set the breakpoint. */
492d29ea 2738 TRY
0000e5cc
PA
2739 {
2740 int val;
2741
2742 val = target_insert_breakpoint (bl->gdbarch,
2743 &bl->overlay_target_info);
2744 if (val)
2745 bp_err = GENERIC_ERROR;
2746 }
492d29ea 2747 CATCH (e, RETURN_MASK_ALL)
0000e5cc
PA
2748 {
2749 bp_err = e.error;
2750 bp_err_message = e.message;
2751 }
492d29ea 2752 END_CATCH
0000e5cc
PA
2753
2754 if (bp_err != GDB_NO_ERROR)
99361f52 2755 fprintf_unfiltered (tmp_error_stream,
3e43a32a
MS
2756 "Overlay breakpoint %d "
2757 "failed: in ROM?\n",
35df4500 2758 bl->owner->number);
879bfdc2
DJ
2759 }
2760 }
2761 /* Shall we set a breakpoint at the VMA? */
35df4500 2762 if (section_is_mapped (bl->section))
879bfdc2
DJ
2763 {
2764 /* Yes. This overlay section is mapped into memory. */
492d29ea 2765 TRY
dd61ec5c 2766 {
0000e5cc
PA
2767 int val;
2768
dd61ec5c 2769 val = bl->owner->ops->insert_location (bl);
0000e5cc
PA
2770 if (val)
2771 bp_err = GENERIC_ERROR;
dd61ec5c 2772 }
492d29ea 2773 CATCH (e, RETURN_MASK_ALL)
dd61ec5c 2774 {
0000e5cc
PA
2775 bp_err = e.error;
2776 bp_err_message = e.message;
dd61ec5c 2777 }
492d29ea 2778 END_CATCH
879bfdc2
DJ
2779 }
2780 else
2781 {
2782 /* No. This breakpoint will not be inserted.
2783 No error, but do not mark the bp as 'inserted'. */
2784 return 0;
2785 }
2786 }
2787
0000e5cc 2788 if (bp_err != GDB_NO_ERROR)
879bfdc2
DJ
2789 {
2790 /* Can't set the breakpoint. */
0000e5cc
PA
2791
2792 /* In some cases, we might not be able to insert a
2793 breakpoint in a shared library that has already been
2794 removed, but we have not yet processed the shlib unload
2795 event. Unfortunately, some targets that implement
076855f9
PA
2796 breakpoint insertion themselves can't tell why the
2797 breakpoint insertion failed (e.g., the remote target
2798 doesn't define error codes), so we must treat generic
2799 errors as memory errors. */
0000e5cc 2800 if ((bp_err == GENERIC_ERROR || bp_err == MEMORY_ERROR)
076855f9 2801 && bl->loc_type == bp_loc_software_breakpoint
08351840 2802 && (solib_name_from_address (bl->pspace, bl->address)
d03de421
PA
2803 || shared_objfile_contains_address_p (bl->pspace,
2804 bl->address)))
879bfdc2 2805 {
4a64f543 2806 /* See also: disable_breakpoints_in_shlibs. */
35df4500 2807 bl->shlib_disabled = 1;
8d3788bd 2808 observer_notify_breakpoint_modified (bl->owner);
3fbb6ffa
TJB
2809 if (!*disabled_breaks)
2810 {
2811 fprintf_unfiltered (tmp_error_stream,
2812 "Cannot insert breakpoint %d.\n",
2813 bl->owner->number);
2814 fprintf_unfiltered (tmp_error_stream,
2815 "Temporarily disabling shared "
2816 "library breakpoints:\n");
2817 }
2818 *disabled_breaks = 1;
879bfdc2 2819 fprintf_unfiltered (tmp_error_stream,
35df4500 2820 "breakpoint #%d\n", bl->owner->number);
0000e5cc 2821 return 0;
879bfdc2
DJ
2822 }
2823 else
879bfdc2 2824 {
35df4500 2825 if (bl->loc_type == bp_loc_hardware_breakpoint)
879bfdc2 2826 {
0000e5cc
PA
2827 *hw_breakpoint_error = 1;
2828 *hw_bp_error_explained_already = bp_err_message != NULL;
dd61ec5c
MW
2829 fprintf_unfiltered (tmp_error_stream,
2830 "Cannot insert hardware breakpoint %d%s",
0000e5cc
PA
2831 bl->owner->number, bp_err_message ? ":" : ".\n");
2832 if (bp_err_message != NULL)
2833 fprintf_unfiltered (tmp_error_stream, "%s.\n", bp_err_message);
879bfdc2
DJ
2834 }
2835 else
2836 {
0000e5cc
PA
2837 if (bp_err_message == NULL)
2838 {
2839 char *message
2840 = memory_error_message (TARGET_XFER_E_IO,
2841 bl->gdbarch, bl->address);
2842 struct cleanup *old_chain = make_cleanup (xfree, message);
2843
2844 fprintf_unfiltered (tmp_error_stream,
2845 "Cannot insert breakpoint %d.\n"
2846 "%s\n",
2847 bl->owner->number, message);
2848 do_cleanups (old_chain);
2849 }
2850 else
2851 {
2852 fprintf_unfiltered (tmp_error_stream,
2853 "Cannot insert breakpoint %d: %s\n",
2854 bl->owner->number,
2855 bp_err_message);
2856 }
879bfdc2 2857 }
0000e5cc 2858 return 1;
879bfdc2
DJ
2859
2860 }
2861 }
2862 else
35df4500 2863 bl->inserted = 1;
879bfdc2 2864
0000e5cc 2865 return 0;
879bfdc2
DJ
2866 }
2867
35df4500 2868 else if (bl->loc_type == bp_loc_hardware_watchpoint
879bfdc2 2869 /* NOTE drow/2003-09-08: This state only exists for removing
4a64f543 2870 watchpoints. It's not clear that it's necessary... */
35df4500 2871 && bl->owner->disposition != disp_del_at_next_stop)
879bfdc2 2872 {
0000e5cc
PA
2873 int val;
2874
77b06cd7
TJB
2875 gdb_assert (bl->owner->ops != NULL
2876 && bl->owner->ops->insert_location != NULL);
2877
2878 val = bl->owner->ops->insert_location (bl);
85d721b8
PA
2879
2880 /* If trying to set a read-watchpoint, and it turns out it's not
2881 supported, try emulating one with an access watchpoint. */
35df4500 2882 if (val == 1 && bl->watchpoint_type == hw_read)
85d721b8
PA
2883 {
2884 struct bp_location *loc, **loc_temp;
2885
2886 /* But don't try to insert it, if there's already another
2887 hw_access location that would be considered a duplicate
2888 of this one. */
2889 ALL_BP_LOCATIONS (loc, loc_temp)
35df4500 2890 if (loc != bl
85d721b8 2891 && loc->watchpoint_type == hw_access
35df4500 2892 && watchpoint_locations_match (bl, loc))
85d721b8 2893 {
35df4500
TJB
2894 bl->duplicate = 1;
2895 bl->inserted = 1;
2896 bl->target_info = loc->target_info;
2897 bl->watchpoint_type = hw_access;
85d721b8
PA
2898 val = 0;
2899 break;
2900 }
2901
2902 if (val == 1)
2903 {
77b06cd7
TJB
2904 bl->watchpoint_type = hw_access;
2905 val = bl->owner->ops->insert_location (bl);
2906
2907 if (val)
2908 /* Back to the original value. */
2909 bl->watchpoint_type = hw_read;
85d721b8
PA
2910 }
2911 }
2912
35df4500 2913 bl->inserted = (val == 0);
879bfdc2
DJ
2914 }
2915
35df4500 2916 else if (bl->owner->type == bp_catchpoint)
879bfdc2 2917 {
0000e5cc
PA
2918 int val;
2919
77b06cd7
TJB
2920 gdb_assert (bl->owner->ops != NULL
2921 && bl->owner->ops->insert_location != NULL);
2922
2923 val = bl->owner->ops->insert_location (bl);
2924 if (val)
2925 {
2926 bl->owner->enable_state = bp_disabled;
2927
2928 if (val == 1)
2929 warning (_("\
2930Error inserting catchpoint %d: Your system does not support this type\n\
2931of catchpoint."), bl->owner->number);
2932 else
2933 warning (_("Error inserting catchpoint %d."), bl->owner->number);
2934 }
2935
2936 bl->inserted = (val == 0);
1640b821
DJ
2937
2938 /* We've already printed an error message if there was a problem
2939 inserting this catchpoint, and we've disabled the catchpoint,
2940 so just return success. */
2941 return 0;
879bfdc2
DJ
2942 }
2943
2944 return 0;
2945}
2946
6c95b8df
PA
2947/* This function is called when program space PSPACE is about to be
2948 deleted. It takes care of updating breakpoints to not reference
2949 PSPACE anymore. */
2950
2951void
2952breakpoint_program_space_exit (struct program_space *pspace)
2953{
2954 struct breakpoint *b, *b_temp;
876fa593 2955 struct bp_location *loc, **loc_temp;
6c95b8df
PA
2956
2957 /* Remove any breakpoint that was set through this program space. */
2958 ALL_BREAKPOINTS_SAFE (b, b_temp)
2959 {
2960 if (b->pspace == pspace)
2961 delete_breakpoint (b);
2962 }
2963
2964 /* Breakpoints set through other program spaces could have locations
2965 bound to PSPACE as well. Remove those. */
876fa593 2966 ALL_BP_LOCATIONS (loc, loc_temp)
6c95b8df
PA
2967 {
2968 struct bp_location *tmp;
2969
2970 if (loc->pspace == pspace)
2971 {
2bdf28a0 2972 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
6c95b8df
PA
2973 if (loc->owner->loc == loc)
2974 loc->owner->loc = loc->next;
2975 else
2976 for (tmp = loc->owner->loc; tmp->next != NULL; tmp = tmp->next)
2977 if (tmp->next == loc)
2978 {
2979 tmp->next = loc->next;
2980 break;
2981 }
2982 }
2983 }
2984
2985 /* Now update the global location list to permanently delete the
2986 removed locations above. */
44702360 2987 update_global_location_list (UGLL_DONT_INSERT);
6c95b8df
PA
2988}
2989
74960c60
VP
2990/* Make sure all breakpoints are inserted in inferior.
2991 Throws exception on any error.
2992 A breakpoint that is already inserted won't be inserted
2993 again, so calling this function twice is safe. */
2994void
2995insert_breakpoints (void)
2996{
2997 struct breakpoint *bpt;
2998
2999 ALL_BREAKPOINTS (bpt)
3000 if (is_hardware_watchpoint (bpt))
3a5c3e22
PA
3001 {
3002 struct watchpoint *w = (struct watchpoint *) bpt;
3003
3004 update_watchpoint (w, 0 /* don't reparse. */);
3005 }
74960c60 3006
04086b45
PA
3007 /* Updating watchpoints creates new locations, so update the global
3008 location list. Explicitly tell ugll to insert locations and
3009 ignore breakpoints_always_inserted_mode. */
3010 update_global_location_list (UGLL_INSERT);
74960c60
VP
3011}
3012
20388dd6
YQ
3013/* Invoke CALLBACK for each of bp_location. */
3014
3015void
3016iterate_over_bp_locations (walk_bp_location_callback callback)
3017{
3018 struct bp_location *loc, **loc_tmp;
3019
3020 ALL_BP_LOCATIONS (loc, loc_tmp)
3021 {
3022 callback (loc, NULL);
3023 }
3024}
3025
b775012e
LM
3026/* This is used when we need to synch breakpoint conditions between GDB and the
3027 target. It is the case with deleting and disabling of breakpoints when using
3028 always-inserted mode. */
3029
3030static void
3031update_inserted_breakpoint_locations (void)
3032{
3033 struct bp_location *bl, **blp_tmp;
3034 int error_flag = 0;
3035 int val = 0;
3036 int disabled_breaks = 0;
3037 int hw_breakpoint_error = 0;
dd61ec5c 3038 int hw_bp_details_reported = 0;
b775012e
LM
3039
3040 struct ui_file *tmp_error_stream = mem_fileopen ();
3041 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
3042
3043 /* Explicitly mark the warning -- this will only be printed if
3044 there was an error. */
3045 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
3046
3047 save_current_space_and_thread ();
3048
3049 ALL_BP_LOCATIONS (bl, blp_tmp)
3050 {
3051 /* We only want to update software breakpoints and hardware
3052 breakpoints. */
3053 if (!is_breakpoint (bl->owner))
3054 continue;
3055
3056 /* We only want to update locations that are already inserted
3057 and need updating. This is to avoid unwanted insertion during
3058 deletion of breakpoints. */
3059 if (!bl->inserted || (bl->inserted && !bl->needs_update))
3060 continue;
3061
3062 switch_to_program_space_and_thread (bl->pspace);
3063
3064 /* For targets that support global breakpoints, there's no need
3065 to select an inferior to insert breakpoint to. In fact, even
3066 if we aren't attached to any process yet, we should still
3067 insert breakpoints. */
f5656ead 3068 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
b775012e
LM
3069 && ptid_equal (inferior_ptid, null_ptid))
3070 continue;
3071
3072 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
dd61ec5c 3073 &hw_breakpoint_error, &hw_bp_details_reported);
b775012e
LM
3074 if (val)
3075 error_flag = val;
3076 }
3077
3078 if (error_flag)
3079 {
3080 target_terminal_ours_for_output ();
3081 error_stream (tmp_error_stream);
3082 }
3083
3084 do_cleanups (cleanups);
3085}
3086
c30eee59 3087/* Used when starting or continuing the program. */
c906108c 3088
74960c60
VP
3089static void
3090insert_breakpoint_locations (void)
c906108c 3091{
a5606eee 3092 struct breakpoint *bpt;
35df4500 3093 struct bp_location *bl, **blp_tmp;
eacd795a 3094 int error_flag = 0;
c906108c 3095 int val = 0;
3fbb6ffa 3096 int disabled_breaks = 0;
81d0cc19 3097 int hw_breakpoint_error = 0;
dd61ec5c 3098 int hw_bp_error_explained_already = 0;
c906108c 3099
81d0cc19 3100 struct ui_file *tmp_error_stream = mem_fileopen ();
f7545552 3101 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
74960c60 3102
81d0cc19
GS
3103 /* Explicitly mark the warning -- this will only be printed if
3104 there was an error. */
3105 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
6c95b8df
PA
3106
3107 save_current_space_and_thread ();
3108
35df4500 3109 ALL_BP_LOCATIONS (bl, blp_tmp)
879bfdc2 3110 {
b775012e 3111 if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
879bfdc2
DJ
3112 continue;
3113
4a64f543
MS
3114 /* There is no point inserting thread-specific breakpoints if
3115 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3116 has BL->OWNER always non-NULL. */
35df4500
TJB
3117 if (bl->owner->thread != -1
3118 && !valid_thread_id (bl->owner->thread))
f365de73
AS
3119 continue;
3120
35df4500 3121 switch_to_program_space_and_thread (bl->pspace);
6c95b8df
PA
3122
3123 /* For targets that support global breakpoints, there's no need
3124 to select an inferior to insert breakpoint to. In fact, even
3125 if we aren't attached to any process yet, we should still
3126 insert breakpoints. */
f5656ead 3127 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
6c95b8df
PA
3128 && ptid_equal (inferior_ptid, null_ptid))
3129 continue;
3130
3fbb6ffa 3131 val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
dd61ec5c 3132 &hw_breakpoint_error, &hw_bp_error_explained_already);
879bfdc2 3133 if (val)
eacd795a 3134 error_flag = val;
879bfdc2 3135 }
c906108c 3136
4a64f543
MS
3137 /* If we failed to insert all locations of a watchpoint, remove
3138 them, as half-inserted watchpoint is of limited use. */
a5606eee
VP
3139 ALL_BREAKPOINTS (bpt)
3140 {
3141 int some_failed = 0;
3142 struct bp_location *loc;
3143
3144 if (!is_hardware_watchpoint (bpt))
3145 continue;
3146
d6b74ac4 3147 if (!breakpoint_enabled (bpt))
a5606eee 3148 continue;
74960c60
VP
3149
3150 if (bpt->disposition == disp_del_at_next_stop)
3151 continue;
a5606eee
VP
3152
3153 for (loc = bpt->loc; loc; loc = loc->next)
56710373 3154 if (!loc->inserted && should_be_inserted (loc))
a5606eee
VP
3155 {
3156 some_failed = 1;
3157 break;
3158 }
3159 if (some_failed)
3160 {
3161 for (loc = bpt->loc; loc; loc = loc->next)
3162 if (loc->inserted)
3163 remove_breakpoint (loc, mark_uninserted);
3164
3165 hw_breakpoint_error = 1;
3166 fprintf_unfiltered (tmp_error_stream,
3167 "Could not insert hardware watchpoint %d.\n",
3168 bpt->number);
eacd795a 3169 error_flag = -1;
a5606eee
VP
3170 }
3171 }
3172
eacd795a 3173 if (error_flag)
81d0cc19
GS
3174 {
3175 /* If a hardware breakpoint or watchpoint was inserted, add a
3176 message about possibly exhausted resources. */
dd61ec5c 3177 if (hw_breakpoint_error && !hw_bp_error_explained_already)
81d0cc19 3178 {
c6510018
MS
3179 fprintf_unfiltered (tmp_error_stream,
3180 "Could not insert hardware breakpoints:\n\
3181You may have requested too many hardware breakpoints/watchpoints.\n");
81d0cc19 3182 }
81d0cc19
GS
3183 target_terminal_ours_for_output ();
3184 error_stream (tmp_error_stream);
3185 }
f7545552
TT
3186
3187 do_cleanups (cleanups);
c906108c
SS
3188}
3189
c30eee59
TJB
3190/* Used when the program stops.
3191 Returns zero if successful, or non-zero if there was a problem
3192 removing a breakpoint location. */
3193
c906108c 3194int
fba45db2 3195remove_breakpoints (void)
c906108c 3196{
35df4500 3197 struct bp_location *bl, **blp_tmp;
3a1bae8e 3198 int val = 0;
c906108c 3199
35df4500 3200 ALL_BP_LOCATIONS (bl, blp_tmp)
c5aa993b 3201 {
1e4d1764 3202 if (bl->inserted && !is_tracepoint (bl->owner))
35df4500 3203 val |= remove_breakpoint (bl, mark_uninserted);
c5aa993b 3204 }
3a1bae8e 3205 return val;
c906108c
SS
3206}
3207
49fa26b0
PA
3208/* When a thread exits, remove breakpoints that are related to
3209 that thread. */
3210
3211static void
3212remove_threaded_breakpoints (struct thread_info *tp, int silent)
3213{
3214 struct breakpoint *b, *b_tmp;
3215
3216 ALL_BREAKPOINTS_SAFE (b, b_tmp)
3217 {
96181529 3218 if (b->thread == tp->num && user_breakpoint_p (b))
49fa26b0
PA
3219 {
3220 b->disposition = disp_del_at_next_stop;
3221
3222 printf_filtered (_("\
46ecd527 3223Thread-specific breakpoint %d deleted - thread %d no longer in the thread list.\n"),
49fa26b0
PA
3224 b->number, tp->num);
3225
3226 /* Hide it from the user. */
3227 b->number = 0;
3228 }
3229 }
3230}
3231
6c95b8df
PA
3232/* Remove breakpoints of process PID. */
3233
3234int
3235remove_breakpoints_pid (int pid)
3236{
35df4500 3237 struct bp_location *bl, **blp_tmp;
6c95b8df
PA
3238 int val;
3239 struct inferior *inf = find_inferior_pid (pid);
3240
35df4500 3241 ALL_BP_LOCATIONS (bl, blp_tmp)
6c95b8df 3242 {
35df4500 3243 if (bl->pspace != inf->pspace)
6c95b8df
PA
3244 continue;
3245
fc126975 3246 if (bl->inserted && !bl->target_info.persist)
6c95b8df 3247 {
35df4500 3248 val = remove_breakpoint (bl, mark_uninserted);
6c95b8df
PA
3249 if (val != 0)
3250 return val;
3251 }
3252 }
3253 return 0;
3254}
3255
c906108c 3256int
fba45db2 3257reattach_breakpoints (int pid)
c906108c 3258{
6c95b8df 3259 struct cleanup *old_chain;
35df4500 3260 struct bp_location *bl, **blp_tmp;
c906108c 3261 int val;
86b887df 3262 struct ui_file *tmp_error_stream;
dd61ec5c 3263 int dummy1 = 0, dummy2 = 0, dummy3 = 0;
6c95b8df
PA
3264 struct inferior *inf;
3265 struct thread_info *tp;
3266
3267 tp = any_live_thread_of_process (pid);
3268 if (tp == NULL)
3269 return 1;
3270
3271 inf = find_inferior_pid (pid);
3272 old_chain = save_inferior_ptid ();
3273
3274 inferior_ptid = tp->ptid;
a4954f26 3275
86b887df 3276 tmp_error_stream = mem_fileopen ();
a4954f26 3277 make_cleanup_ui_file_delete (tmp_error_stream);
c906108c 3278
35df4500 3279 ALL_BP_LOCATIONS (bl, blp_tmp)
c5aa993b 3280 {
35df4500 3281 if (bl->pspace != inf->pspace)
6c95b8df
PA
3282 continue;
3283
35df4500 3284 if (bl->inserted)
c5aa993b 3285 {
35df4500 3286 bl->inserted = 0;
dd61ec5c 3287 val = insert_bp_location (bl, tmp_error_stream, &dummy1, &dummy2, &dummy3);
c5aa993b
JM
3288 if (val != 0)
3289 {
ce696e05 3290 do_cleanups (old_chain);
c5aa993b
JM
3291 return val;
3292 }
3293 }
3294 }
ce696e05 3295 do_cleanups (old_chain);
c906108c
SS
3296 return 0;
3297}
3298
e58b0e63
PA
3299static int internal_breakpoint_number = -1;
3300
84f4c1fe
PM
3301/* Set the breakpoint number of B, depending on the value of INTERNAL.
3302 If INTERNAL is non-zero, the breakpoint number will be populated
3303 from internal_breakpoint_number and that variable decremented.
e5dd4106 3304 Otherwise the breakpoint number will be populated from
84f4c1fe
PM
3305 breakpoint_count and that value incremented. Internal breakpoints
3306 do not set the internal var bpnum. */
3307static void
3308set_breakpoint_number (int internal, struct breakpoint *b)
3309{
3310 if (internal)
3311 b->number = internal_breakpoint_number--;
3312 else
3313 {
3314 set_breakpoint_count (breakpoint_count + 1);
3315 b->number = breakpoint_count;
3316 }
3317}
3318
e62c965a 3319static struct breakpoint *
a6d9a66e 3320create_internal_breakpoint (struct gdbarch *gdbarch,
06edf0c0 3321 CORE_ADDR address, enum bptype type,
c0a91b2b 3322 const struct breakpoint_ops *ops)
e62c965a 3323{
e62c965a
PP
3324 struct symtab_and_line sal;
3325 struct breakpoint *b;
3326
4a64f543 3327 init_sal (&sal); /* Initialize to zeroes. */
e62c965a
PP
3328
3329 sal.pc = address;
3330 sal.section = find_pc_overlay (sal.pc);
6c95b8df 3331 sal.pspace = current_program_space;
e62c965a 3332
06edf0c0 3333 b = set_raw_breakpoint (gdbarch, sal, type, ops);
e62c965a
PP
3334 b->number = internal_breakpoint_number--;
3335 b->disposition = disp_donttouch;
3336
3337 return b;
3338}
3339
17450429
PP
3340static const char *const longjmp_names[] =
3341 {
3342 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3343 };
3344#define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3345
3346/* Per-objfile data private to breakpoint.c. */
3347struct breakpoint_objfile_data
3348{
3349 /* Minimal symbol for "_ovly_debug_event" (if any). */
3b7344d5 3350 struct bound_minimal_symbol overlay_msym;
17450429
PP
3351
3352 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3b7344d5 3353 struct bound_minimal_symbol longjmp_msym[NUM_LONGJMP_NAMES];
17450429 3354
28106bc2
SDJ
3355 /* True if we have looked for longjmp probes. */
3356 int longjmp_searched;
3357
3358 /* SystemTap probe points for longjmp (if any). */
3359 VEC (probe_p) *longjmp_probes;
3360
17450429 3361 /* Minimal symbol for "std::terminate()" (if any). */
3b7344d5 3362 struct bound_minimal_symbol terminate_msym;
17450429
PP
3363
3364 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3b7344d5 3365 struct bound_minimal_symbol exception_msym;
28106bc2
SDJ
3366
3367 /* True if we have looked for exception probes. */
3368 int exception_searched;
3369
3370 /* SystemTap probe points for unwinding (if any). */
3371 VEC (probe_p) *exception_probes;
17450429
PP
3372};
3373
3374static const struct objfile_data *breakpoint_objfile_key;
3375
3376/* Minimal symbol not found sentinel. */
3377static struct minimal_symbol msym_not_found;
3378
3379/* Returns TRUE if MSYM point to the "not found" sentinel. */
3380
3381static int
3382msym_not_found_p (const struct minimal_symbol *msym)
3383{
3384 return msym == &msym_not_found;
3385}
3386
3387/* Return per-objfile data needed by breakpoint.c.
3388 Allocate the data if necessary. */
3389
3390static struct breakpoint_objfile_data *
3391get_breakpoint_objfile_data (struct objfile *objfile)
3392{
3393 struct breakpoint_objfile_data *bp_objfile_data;
3394
3395 bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
3396 if (bp_objfile_data == NULL)
3397 {
8d749320
SM
3398 bp_objfile_data =
3399 XOBNEW (&objfile->objfile_obstack, struct breakpoint_objfile_data);
17450429
PP
3400
3401 memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
3402 set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
3403 }
3404 return bp_objfile_data;
3405}
3406
28106bc2
SDJ
3407static void
3408free_breakpoint_probes (struct objfile *obj, void *data)
3409{
3410 struct breakpoint_objfile_data *bp_objfile_data = data;
3411
3412 VEC_free (probe_p, bp_objfile_data->longjmp_probes);
3413 VEC_free (probe_p, bp_objfile_data->exception_probes);
3414}
3415
e62c965a 3416static void
af02033e 3417create_overlay_event_breakpoint (void)
e62c965a 3418{
69de3c6a 3419 struct objfile *objfile;
af02033e 3420 const char *const func_name = "_ovly_debug_event";
e62c965a 3421
69de3c6a
PP
3422 ALL_OBJFILES (objfile)
3423 {
3424 struct breakpoint *b;
17450429
PP
3425 struct breakpoint_objfile_data *bp_objfile_data;
3426 CORE_ADDR addr;
67994074 3427 struct explicit_location explicit_loc;
69de3c6a 3428
17450429
PP
3429 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3430
3b7344d5 3431 if (msym_not_found_p (bp_objfile_data->overlay_msym.minsym))
17450429
PP
3432 continue;
3433
3b7344d5 3434 if (bp_objfile_data->overlay_msym.minsym == NULL)
17450429 3435 {
3b7344d5 3436 struct bound_minimal_symbol m;
17450429
PP
3437
3438 m = lookup_minimal_symbol_text (func_name, objfile);
3b7344d5 3439 if (m.minsym == NULL)
17450429
PP
3440 {
3441 /* Avoid future lookups in this objfile. */
3b7344d5 3442 bp_objfile_data->overlay_msym.minsym = &msym_not_found;
17450429
PP
3443 continue;
3444 }
3445 bp_objfile_data->overlay_msym = m;
3446 }
e62c965a 3447
77e371c0 3448 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
17450429 3449 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
06edf0c0
PA
3450 bp_overlay_event,
3451 &internal_breakpoint_ops);
67994074
KS
3452 initialize_explicit_location (&explicit_loc);
3453 explicit_loc.function_name = ASTRDUP (func_name);
3454 b->location = new_explicit_location (&explicit_loc);
e62c965a 3455
69de3c6a
PP
3456 if (overlay_debugging == ovly_auto)
3457 {
3458 b->enable_state = bp_enabled;
3459 overlay_events_enabled = 1;
3460 }
3461 else
3462 {
3463 b->enable_state = bp_disabled;
3464 overlay_events_enabled = 0;
3465 }
e62c965a 3466 }
44702360 3467 update_global_location_list (UGLL_MAY_INSERT);
e62c965a
PP
3468}
3469
0fd8e87f 3470static void
af02033e 3471create_longjmp_master_breakpoint (void)
0fd8e87f 3472{
6c95b8df 3473 struct program_space *pspace;
6c95b8df
PA
3474 struct cleanup *old_chain;
3475
3476 old_chain = save_current_program_space ();
0fd8e87f 3477
6c95b8df 3478 ALL_PSPACES (pspace)
af02033e
PP
3479 {
3480 struct objfile *objfile;
3481
3482 set_current_program_space (pspace);
3483
3484 ALL_OBJFILES (objfile)
0fd8e87f 3485 {
af02033e
PP
3486 int i;
3487 struct gdbarch *gdbarch;
17450429 3488 struct breakpoint_objfile_data *bp_objfile_data;
0fd8e87f 3489
af02033e 3490 gdbarch = get_objfile_arch (objfile);
0fd8e87f 3491
17450429
PP
3492 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3493
28106bc2
SDJ
3494 if (!bp_objfile_data->longjmp_searched)
3495 {
25f9533e
SDJ
3496 VEC (probe_p) *ret;
3497
3498 ret = find_probes_in_objfile (objfile, "libc", "longjmp");
3499 if (ret != NULL)
3500 {
3501 /* We are only interested in checking one element. */
3502 struct probe *p = VEC_index (probe_p, ret, 0);
3503
3504 if (!can_evaluate_probe_arguments (p))
3505 {
3506 /* We cannot use the probe interface here, because it does
3507 not know how to evaluate arguments. */
3508 VEC_free (probe_p, ret);
3509 ret = NULL;
3510 }
3511 }
3512 bp_objfile_data->longjmp_probes = ret;
28106bc2
SDJ
3513 bp_objfile_data->longjmp_searched = 1;
3514 }
3515
3516 if (bp_objfile_data->longjmp_probes != NULL)
3517 {
3518 int i;
3519 struct probe *probe;
3520 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3521
3522 for (i = 0;
3523 VEC_iterate (probe_p,
3524 bp_objfile_data->longjmp_probes,
3525 i, probe);
3526 ++i)
3527 {
3528 struct breakpoint *b;
3529
729662a5
TT
3530 b = create_internal_breakpoint (gdbarch,
3531 get_probe_address (probe,
3532 objfile),
28106bc2
SDJ
3533 bp_longjmp_master,
3534 &internal_breakpoint_ops);
5b56227b
KS
3535 b->location
3536 = new_probe_location ("-probe-stap libc:longjmp");
28106bc2
SDJ
3537 b->enable_state = bp_disabled;
3538 }
3539
3540 continue;
3541 }
3542
0569175e
TSD
3543 if (!gdbarch_get_longjmp_target_p (gdbarch))
3544 continue;
3545
17450429 3546 for (i = 0; i < NUM_LONGJMP_NAMES; i++)
af02033e
PP
3547 {
3548 struct breakpoint *b;
af02033e 3549 const char *func_name;
17450429 3550 CORE_ADDR addr;
67994074 3551 struct explicit_location explicit_loc;
6c95b8df 3552
3b7344d5 3553 if (msym_not_found_p (bp_objfile_data->longjmp_msym[i].minsym))
af02033e 3554 continue;
0fd8e87f 3555
17450429 3556 func_name = longjmp_names[i];
3b7344d5 3557 if (bp_objfile_data->longjmp_msym[i].minsym == NULL)
17450429 3558 {
3b7344d5 3559 struct bound_minimal_symbol m;
17450429
PP
3560
3561 m = lookup_minimal_symbol_text (func_name, objfile);
3b7344d5 3562 if (m.minsym == NULL)
17450429
PP
3563 {
3564 /* Prevent future lookups in this objfile. */
3b7344d5 3565 bp_objfile_data->longjmp_msym[i].minsym = &msym_not_found;
17450429
PP
3566 continue;
3567 }
3568 bp_objfile_data->longjmp_msym[i] = m;
3569 }
3570
77e371c0 3571 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
06edf0c0
PA
3572 b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
3573 &internal_breakpoint_ops);
67994074
KS
3574 initialize_explicit_location (&explicit_loc);
3575 explicit_loc.function_name = ASTRDUP (func_name);
3576 b->location = new_explicit_location (&explicit_loc);
af02033e
PP
3577 b->enable_state = bp_disabled;
3578 }
0fd8e87f 3579 }
af02033e 3580 }
44702360 3581 update_global_location_list (UGLL_MAY_INSERT);
6c95b8df
PA
3582
3583 do_cleanups (old_chain);
0fd8e87f
UW
3584}
3585
af02033e 3586/* Create a master std::terminate breakpoint. */
aa7d318d 3587static void
af02033e 3588create_std_terminate_master_breakpoint (void)
aa7d318d
TT
3589{
3590 struct program_space *pspace;
aa7d318d 3591 struct cleanup *old_chain;
af02033e 3592 const char *const func_name = "std::terminate()";
aa7d318d
TT
3593
3594 old_chain = save_current_program_space ();
3595
3596 ALL_PSPACES (pspace)
17450429
PP
3597 {
3598 struct objfile *objfile;
3599 CORE_ADDR addr;
3600
3601 set_current_program_space (pspace);
3602
aa7d318d
TT
3603 ALL_OBJFILES (objfile)
3604 {
3605 struct breakpoint *b;
17450429 3606 struct breakpoint_objfile_data *bp_objfile_data;
67994074 3607 struct explicit_location explicit_loc;
aa7d318d 3608
17450429 3609 bp_objfile_data = get_breakpoint_objfile_data (objfile);
aa7d318d 3610
3b7344d5 3611 if (msym_not_found_p (bp_objfile_data->terminate_msym.minsym))
17450429
PP
3612 continue;
3613
3b7344d5 3614 if (bp_objfile_data->terminate_msym.minsym == NULL)
17450429 3615 {
3b7344d5 3616 struct bound_minimal_symbol m;
17450429
PP
3617
3618 m = lookup_minimal_symbol (func_name, NULL, objfile);
3b7344d5
TT
3619 if (m.minsym == NULL || (MSYMBOL_TYPE (m.minsym) != mst_text
3620 && MSYMBOL_TYPE (m.minsym) != mst_file_text))
17450429
PP
3621 {
3622 /* Prevent future lookups in this objfile. */
3b7344d5 3623 bp_objfile_data->terminate_msym.minsym = &msym_not_found;
17450429
PP
3624 continue;
3625 }
3626 bp_objfile_data->terminate_msym = m;
3627 }
aa7d318d 3628
77e371c0 3629 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
17450429 3630 b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
06edf0c0
PA
3631 bp_std_terminate_master,
3632 &internal_breakpoint_ops);
67994074
KS
3633 initialize_explicit_location (&explicit_loc);
3634 explicit_loc.function_name = ASTRDUP (func_name);
3635 b->location = new_explicit_location (&explicit_loc);
aa7d318d
TT
3636 b->enable_state = bp_disabled;
3637 }
17450429
PP
3638 }
3639
44702360 3640 update_global_location_list (UGLL_MAY_INSERT);
aa7d318d
TT
3641
3642 do_cleanups (old_chain);
3643}
3644
186c406b
TT
3645/* Install a master breakpoint on the unwinder's debug hook. */
3646
70221824 3647static void
186c406b
TT
3648create_exception_master_breakpoint (void)
3649{
3650 struct objfile *objfile;
17450429 3651 const char *const func_name = "_Unwind_DebugHook";
186c406b
TT
3652
3653 ALL_OBJFILES (objfile)
3654 {
17450429
PP
3655 struct breakpoint *b;
3656 struct gdbarch *gdbarch;
3657 struct breakpoint_objfile_data *bp_objfile_data;
3658 CORE_ADDR addr;
67994074 3659 struct explicit_location explicit_loc;
17450429
PP
3660
3661 bp_objfile_data = get_breakpoint_objfile_data (objfile);
3662
28106bc2
SDJ
3663 /* We prefer the SystemTap probe point if it exists. */
3664 if (!bp_objfile_data->exception_searched)
3665 {
25f9533e
SDJ
3666 VEC (probe_p) *ret;
3667
3668 ret = find_probes_in_objfile (objfile, "libgcc", "unwind");
3669
3670 if (ret != NULL)
3671 {
3672 /* We are only interested in checking one element. */
3673 struct probe *p = VEC_index (probe_p, ret, 0);
3674
3675 if (!can_evaluate_probe_arguments (p))
3676 {
3677 /* We cannot use the probe interface here, because it does
3678 not know how to evaluate arguments. */
3679 VEC_free (probe_p, ret);
3680 ret = NULL;
3681 }
3682 }
3683 bp_objfile_data->exception_probes = ret;
28106bc2
SDJ
3684 bp_objfile_data->exception_searched = 1;
3685 }
3686
3687 if (bp_objfile_data->exception_probes != NULL)
3688 {
3689 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3690 int i;
3691 struct probe *probe;
3692
3693 for (i = 0;
3694 VEC_iterate (probe_p,
3695 bp_objfile_data->exception_probes,
3696 i, probe);
3697 ++i)
3698 {
3699 struct breakpoint *b;
3700
729662a5
TT
3701 b = create_internal_breakpoint (gdbarch,
3702 get_probe_address (probe,
3703 objfile),
28106bc2
SDJ
3704 bp_exception_master,
3705 &internal_breakpoint_ops);
5b56227b
KS
3706 b->location
3707 = new_probe_location ("-probe-stap libgcc:unwind");
28106bc2
SDJ
3708 b->enable_state = bp_disabled;
3709 }
3710
3711 continue;
3712 }
3713
3714 /* Otherwise, try the hook function. */
3715
3b7344d5 3716 if (msym_not_found_p (bp_objfile_data->exception_msym.minsym))
17450429
PP
3717 continue;
3718
3719 gdbarch = get_objfile_arch (objfile);
186c406b 3720
3b7344d5 3721 if (bp_objfile_data->exception_msym.minsym == NULL)
186c406b 3722 {
3b7344d5 3723 struct bound_minimal_symbol debug_hook;
186c406b 3724
17450429 3725 debug_hook = lookup_minimal_symbol (func_name, NULL, objfile);
3b7344d5 3726 if (debug_hook.minsym == NULL)
17450429 3727 {
3b7344d5 3728 bp_objfile_data->exception_msym.minsym = &msym_not_found;
17450429
PP
3729 continue;
3730 }
3731
3732 bp_objfile_data->exception_msym = debug_hook;
186c406b 3733 }
17450429 3734
77e371c0 3735 addr = BMSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
17450429
PP
3736 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
3737 &current_target);
06edf0c0
PA
3738 b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
3739 &internal_breakpoint_ops);
67994074
KS
3740 initialize_explicit_location (&explicit_loc);
3741 explicit_loc.function_name = ASTRDUP (func_name);
3742 b->location = new_explicit_location (&explicit_loc);
17450429 3743 b->enable_state = bp_disabled;
186c406b
TT
3744 }
3745
44702360 3746 update_global_location_list (UGLL_MAY_INSERT);
186c406b
TT
3747}
3748
c906108c 3749void
fba45db2 3750update_breakpoints_after_exec (void)
c906108c 3751{
35df4500 3752 struct breakpoint *b, *b_tmp;
876fa593 3753 struct bp_location *bploc, **bplocp_tmp;
c906108c 3754
25b22b0a
PA
3755 /* We're about to delete breakpoints from GDB's lists. If the
3756 INSERTED flag is true, GDB will try to lift the breakpoints by
3757 writing the breakpoints' "shadow contents" back into memory. The
3758 "shadow contents" are NOT valid after an exec, so GDB should not
3759 do that. Instead, the target is responsible from marking
3760 breakpoints out as soon as it detects an exec. We don't do that
3761 here instead, because there may be other attempts to delete
3762 breakpoints after detecting an exec and before reaching here. */
876fa593 3763 ALL_BP_LOCATIONS (bploc, bplocp_tmp)
6c95b8df
PA
3764 if (bploc->pspace == current_program_space)
3765 gdb_assert (!bploc->inserted);
c906108c 3766
35df4500 3767 ALL_BREAKPOINTS_SAFE (b, b_tmp)
c5aa993b 3768 {
6c95b8df
PA
3769 if (b->pspace != current_program_space)
3770 continue;
3771
4a64f543 3772 /* Solib breakpoints must be explicitly reset after an exec(). */
c5aa993b
JM
3773 if (b->type == bp_shlib_event)
3774 {
3775 delete_breakpoint (b);
3776 continue;
3777 }
c906108c 3778
4a64f543 3779 /* JIT breakpoints must be explicitly reset after an exec(). */
4efc6507
DE
3780 if (b->type == bp_jit_event)
3781 {
3782 delete_breakpoint (b);
3783 continue;
3784 }
3785
1900040c 3786 /* Thread event breakpoints must be set anew after an exec(),
0fd8e87f
UW
3787 as must overlay event and longjmp master breakpoints. */
3788 if (b->type == bp_thread_event || b->type == bp_overlay_event
186c406b
TT
3789 || b->type == bp_longjmp_master || b->type == bp_std_terminate_master
3790 || b->type == bp_exception_master)
c4093a6a
JM
3791 {
3792 delete_breakpoint (b);
3793 continue;
3794 }
3795
4a64f543 3796 /* Step-resume breakpoints are meaningless after an exec(). */
2c03e5be 3797 if (b->type == bp_step_resume || b->type == bp_hp_step_resume)
c5aa993b
JM
3798 {
3799 delete_breakpoint (b);
3800 continue;
3801 }
3802
7c16b83e
PA
3803 /* Just like single-step breakpoints. */
3804 if (b->type == bp_single_step)
3805 {
3806 delete_breakpoint (b);
3807 continue;
3808 }
3809
611c83ae
PA
3810 /* Longjmp and longjmp-resume breakpoints are also meaningless
3811 after an exec. */
186c406b 3812 if (b->type == bp_longjmp || b->type == bp_longjmp_resume
e2e4d78b 3813 || b->type == bp_longjmp_call_dummy
186c406b 3814 || b->type == bp_exception || b->type == bp_exception_resume)
611c83ae
PA
3815 {
3816 delete_breakpoint (b);
3817 continue;
3818 }
3819
ce78b96d
JB
3820 if (b->type == bp_catchpoint)
3821 {
3822 /* For now, none of the bp_catchpoint breakpoints need to
3823 do anything at this point. In the future, if some of
3824 the catchpoints need to something, we will need to add
3825 a new method, and call this method from here. */
3826 continue;
3827 }
3828
c5aa993b
JM
3829 /* bp_finish is a special case. The only way we ought to be able
3830 to see one of these when an exec() has happened, is if the user
3831 caught a vfork, and then said "finish". Ordinarily a finish just
3832 carries them to the call-site of the current callee, by setting
3833 a temporary bp there and resuming. But in this case, the finish
3834 will carry them entirely through the vfork & exec.
3835
3836 We don't want to allow a bp_finish to remain inserted now. But
3837 we can't safely delete it, 'cause finish_command has a handle to
3838 the bp on a bpstat, and will later want to delete it. There's a
3839 chance (and I've seen it happen) that if we delete the bp_finish
3840 here, that its storage will get reused by the time finish_command
3841 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3842 We really must allow finish_command to delete a bp_finish.
3843
e5dd4106 3844 In the absence of a general solution for the "how do we know
53a5351d
JM
3845 it's safe to delete something others may have handles to?"
3846 problem, what we'll do here is just uninsert the bp_finish, and
3847 let finish_command delete it.
3848
3849 (We know the bp_finish is "doomed" in the sense that it's
3850 momentary, and will be deleted as soon as finish_command sees
3851 the inferior stopped. So it doesn't matter that the bp's
3852 address is probably bogus in the new a.out, unlike e.g., the
3853 solib breakpoints.) */
c5aa993b 3854
c5aa993b
JM
3855 if (b->type == bp_finish)
3856 {
3857 continue;
3858 }
3859
3860 /* Without a symbolic address, we have little hope of the
3861 pre-exec() address meaning the same thing in the post-exec()
4a64f543 3862 a.out. */
f00aae0f 3863 if (event_location_empty_p (b->location))
c5aa993b
JM
3864 {
3865 delete_breakpoint (b);
3866 continue;
3867 }
c5aa993b 3868 }
c906108c
SS
3869}
3870
3871int
d80ee84f 3872detach_breakpoints (ptid_t ptid)
c906108c 3873{
35df4500 3874 struct bp_location *bl, **blp_tmp;
3a1bae8e 3875 int val = 0;
ce696e05 3876 struct cleanup *old_chain = save_inferior_ptid ();
6c95b8df 3877 struct inferior *inf = current_inferior ();
c5aa993b 3878
dfd4cc63 3879 if (ptid_get_pid (ptid) == ptid_get_pid (inferior_ptid))
8a3fe4f8 3880 error (_("Cannot detach breakpoints of inferior_ptid"));
c5aa993b 3881
6c95b8df 3882 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
d80ee84f 3883 inferior_ptid = ptid;
35df4500 3884 ALL_BP_LOCATIONS (bl, blp_tmp)
c5aa993b 3885 {
35df4500 3886 if (bl->pspace != inf->pspace)
6c95b8df
PA
3887 continue;
3888
bd9673a4
PW
3889 /* This function must physically remove breakpoints locations
3890 from the specified ptid, without modifying the breakpoint
3891 package's state. Locations of type bp_loc_other are only
3892 maintained at GDB side. So, there is no need to remove
3893 these bp_loc_other locations. Moreover, removing these
3894 would modify the breakpoint package's state. */
3895 if (bl->loc_type == bp_loc_other)
3896 continue;
3897
35df4500
TJB
3898 if (bl->inserted)
3899 val |= remove_breakpoint_1 (bl, mark_inserted);
c5aa993b 3900 }
d03285ec 3901
ce696e05 3902 do_cleanups (old_chain);
3a1bae8e 3903 return val;
c906108c
SS
3904}
3905
35df4500 3906/* Remove the breakpoint location BL from the current address space.
6c95b8df
PA
3907 Note that this is used to detach breakpoints from a child fork.
3908 When we get here, the child isn't in the inferior list, and neither
3909 do we have objects to represent its address space --- we should
35df4500 3910 *not* look at bl->pspace->aspace here. */
6c95b8df 3911
c906108c 3912static int
35df4500 3913remove_breakpoint_1 (struct bp_location *bl, insertion_state_t is)
c906108c
SS
3914{
3915 int val;
c5aa993b 3916
35df4500
TJB
3917 /* BL is never in moribund_locations by our callers. */
3918 gdb_assert (bl->owner != NULL);
2bdf28a0 3919
74960c60
VP
3920 /* The type of none suggests that owner is actually deleted.
3921 This should not ever happen. */
35df4500 3922 gdb_assert (bl->owner->type != bp_none);
0bde7532 3923
35df4500
TJB
3924 if (bl->loc_type == bp_loc_software_breakpoint
3925 || bl->loc_type == bp_loc_hardware_breakpoint)
c906108c 3926 {
c02f5703
MS
3927 /* "Normal" instruction breakpoint: either the standard
3928 trap-instruction bp (bp_breakpoint), or a
3929 bp_hardware_breakpoint. */
3930
3931 /* First check to see if we have to handle an overlay. */
3932 if (overlay_debugging == ovly_off
35df4500
TJB
3933 || bl->section == NULL
3934 || !(section_is_overlay (bl->section)))
c02f5703
MS
3935 {
3936 /* No overlay handling: just remove the breakpoint. */
08351840
PA
3937
3938 /* If we're trying to uninsert a memory breakpoint that we
3939 know is set in a dynamic object that is marked
3940 shlib_disabled, then either the dynamic object was
3941 removed with "remove-symbol-file" or with
3942 "nosharedlibrary". In the former case, we don't know
3943 whether another dynamic object might have loaded over the
3944 breakpoint's address -- the user might well let us know
3945 about it next with add-symbol-file (the whole point of
d03de421 3946 add-symbol-file is letting the user manually maintain a
08351840
PA
3947 list of dynamically loaded objects). If we have the
3948 breakpoint's shadow memory, that is, this is a software
3949 breakpoint managed by GDB, check whether the breakpoint
3950 is still inserted in memory, to avoid overwriting wrong
3951 code with stale saved shadow contents. Note that HW
3952 breakpoints don't have shadow memory, as they're
3953 implemented using a mechanism that is not dependent on
3954 being able to modify the target's memory, and as such
3955 they should always be removed. */
3956 if (bl->shlib_disabled
3957 && bl->target_info.shadow_len != 0
3958 && !memory_validate_breakpoint (bl->gdbarch, &bl->target_info))
3959 val = 0;
3960 else
3961 val = bl->owner->ops->remove_location (bl);
c02f5703 3962 }
c906108c
SS
3963 else
3964 {
4a64f543 3965 /* This breakpoint is in an overlay section.
c02f5703
MS
3966 Did we set a breakpoint at the LMA? */
3967 if (!overlay_events_enabled)
3968 {
3969 /* Yes -- overlay event support is not active, so we
3970 should have set a breakpoint at the LMA. Remove it.
3971 */
c02f5703
MS
3972 /* Ignore any failures: if the LMA is in ROM, we will
3973 have already warned when we failed to insert it. */
35df4500
TJB
3974 if (bl->loc_type == bp_loc_hardware_breakpoint)
3975 target_remove_hw_breakpoint (bl->gdbarch,
3976 &bl->overlay_target_info);
c02f5703 3977 else
35df4500
TJB
3978 target_remove_breakpoint (bl->gdbarch,
3979 &bl->overlay_target_info);
c02f5703
MS
3980 }
3981 /* Did we set a breakpoint at the VMA?
3982 If so, we will have marked the breakpoint 'inserted'. */
35df4500 3983 if (bl->inserted)
c906108c 3984 {
c02f5703
MS
3985 /* Yes -- remove it. Previously we did not bother to
3986 remove the breakpoint if the section had been
3987 unmapped, but let's not rely on that being safe. We
3988 don't know what the overlay manager might do. */
aa67235e
UW
3989
3990 /* However, we should remove *software* breakpoints only
3991 if the section is still mapped, or else we overwrite
3992 wrong code with the saved shadow contents. */
348d480f
PA
3993 if (bl->loc_type == bp_loc_hardware_breakpoint
3994 || section_is_mapped (bl->section))
3995 val = bl->owner->ops->remove_location (bl);
aa67235e
UW
3996 else
3997 val = 0;
c906108c 3998 }
c02f5703
MS
3999 else
4000 {
4001 /* No -- not inserted, so no need to remove. No error. */
4002 val = 0;
4003 }
c906108c 4004 }
879d1e6b 4005
08351840
PA
4006 /* In some cases, we might not be able to remove a breakpoint in
4007 a shared library that has already been removed, but we have
4008 not yet processed the shlib unload event. Similarly for an
4009 unloaded add-symbol-file object - the user might not yet have
4010 had the chance to remove-symbol-file it. shlib_disabled will
4011 be set if the library/object has already been removed, but
4012 the breakpoint hasn't been uninserted yet, e.g., after
4013 "nosharedlibrary" or "remove-symbol-file" with breakpoints
4014 always-inserted mode. */
076855f9 4015 if (val
08351840
PA
4016 && (bl->loc_type == bp_loc_software_breakpoint
4017 && (bl->shlib_disabled
4018 || solib_name_from_address (bl->pspace, bl->address)
d03de421
PA
4019 || shared_objfile_contains_address_p (bl->pspace,
4020 bl->address))))
879d1e6b
UW
4021 val = 0;
4022
c906108c
SS
4023 if (val)
4024 return val;
35df4500 4025 bl->inserted = (is == mark_inserted);
c906108c 4026 }
35df4500 4027 else if (bl->loc_type == bp_loc_hardware_watchpoint)
c906108c 4028 {
77b06cd7
TJB
4029 gdb_assert (bl->owner->ops != NULL
4030 && bl->owner->ops->remove_location != NULL);
4031
35df4500 4032 bl->inserted = (is == mark_inserted);
77b06cd7 4033 bl->owner->ops->remove_location (bl);
2e70b7b9 4034
c906108c 4035 /* Failure to remove any of the hardware watchpoints comes here. */
35df4500 4036 if ((is == mark_uninserted) && (bl->inserted))
8a3fe4f8 4037 warning (_("Could not remove hardware watchpoint %d."),
35df4500 4038 bl->owner->number);
c906108c 4039 }
35df4500
TJB
4040 else if (bl->owner->type == bp_catchpoint
4041 && breakpoint_enabled (bl->owner)
4042 && !bl->duplicate)
ce78b96d 4043 {
77b06cd7
TJB
4044 gdb_assert (bl->owner->ops != NULL
4045 && bl->owner->ops->remove_location != NULL);
ce78b96d 4046
77b06cd7 4047 val = bl->owner->ops->remove_location (bl);
ce78b96d
JB
4048 if (val)
4049 return val;
77b06cd7 4050
35df4500 4051 bl->inserted = (is == mark_inserted);
ce78b96d 4052 }
c906108c
SS
4053
4054 return 0;
4055}
4056
6c95b8df 4057static int
35df4500 4058remove_breakpoint (struct bp_location *bl, insertion_state_t is)
6c95b8df
PA
4059{
4060 int ret;
4061 struct cleanup *old_chain;
4062
35df4500
TJB
4063 /* BL is never in moribund_locations by our callers. */
4064 gdb_assert (bl->owner != NULL);
2bdf28a0 4065
6c95b8df
PA
4066 /* The type of none suggests that owner is actually deleted.
4067 This should not ever happen. */
35df4500 4068 gdb_assert (bl->owner->type != bp_none);
6c95b8df
PA
4069
4070 old_chain = save_current_space_and_thread ();
4071
35df4500 4072 switch_to_program_space_and_thread (bl->pspace);
6c95b8df 4073
35df4500 4074 ret = remove_breakpoint_1 (bl, is);
6c95b8df
PA
4075
4076 do_cleanups (old_chain);
4077 return ret;
4078}
4079
c906108c
SS
4080/* Clear the "inserted" flag in all breakpoints. */
4081
25b22b0a 4082void
fba45db2 4083mark_breakpoints_out (void)
c906108c 4084{
35df4500 4085 struct bp_location *bl, **blp_tmp;
c906108c 4086
35df4500 4087 ALL_BP_LOCATIONS (bl, blp_tmp)
66c4b3e8 4088 if (bl->pspace == current_program_space)
35df4500 4089 bl->inserted = 0;
c906108c
SS
4090}
4091
53a5351d
JM
4092/* Clear the "inserted" flag in all breakpoints and delete any
4093 breakpoints which should go away between runs of the program.
c906108c
SS
4094
4095 Plus other such housekeeping that has to be done for breakpoints
4096 between runs.
4097
53a5351d
JM
4098 Note: this function gets called at the end of a run (by
4099 generic_mourn_inferior) and when a run begins (by
4a64f543 4100 init_wait_for_inferior). */
c906108c
SS
4101
4102
4103
4104void
fba45db2 4105breakpoint_init_inferior (enum inf_context context)
c906108c 4106{
35df4500
TJB
4107 struct breakpoint *b, *b_tmp;
4108 struct bp_location *bl, **blp_tmp;
1c5cfe86 4109 int ix;
6c95b8df 4110 struct program_space *pspace = current_program_space;
c906108c 4111
50c71eaf
PA
4112 /* If breakpoint locations are shared across processes, then there's
4113 nothing to do. */
f5656ead 4114 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
50c71eaf
PA
4115 return;
4116
1a853c52 4117 mark_breakpoints_out ();
075f6582 4118
35df4500 4119 ALL_BREAKPOINTS_SAFE (b, b_tmp)
c5aa993b 4120 {
6c95b8df
PA
4121 if (b->loc && b->loc->pspace != pspace)
4122 continue;
4123
c5aa993b
JM
4124 switch (b->type)
4125 {
4126 case bp_call_dummy:
e2e4d78b 4127 case bp_longjmp_call_dummy:
c906108c 4128
c5aa993b 4129 /* If the call dummy breakpoint is at the entry point it will
ab92d69b
PA
4130 cause problems when the inferior is rerun, so we better get
4131 rid of it. */
4132
4133 case bp_watchpoint_scope:
4134
4135 /* Also get rid of scope breakpoints. */
4136
4137 case bp_shlib_event:
4138
4139 /* Also remove solib event breakpoints. Their addresses may
4140 have changed since the last time we ran the program.
4141 Actually we may now be debugging against different target;
4142 and so the solib backend that installed this breakpoint may
4143 not be used in by the target. E.g.,
4144
4145 (gdb) file prog-linux
4146 (gdb) run # native linux target
4147 ...
4148 (gdb) kill
4149 (gdb) file prog-win.exe
4150 (gdb) tar rem :9999 # remote Windows gdbserver.
4151 */
c906108c 4152
f59f708a
PA
4153 case bp_step_resume:
4154
4155 /* Also remove step-resume breakpoints. */
4156
7c16b83e
PA
4157 case bp_single_step:
4158
4159 /* Also remove single-step breakpoints. */
4160
c5aa993b
JM
4161 delete_breakpoint (b);
4162 break;
c906108c 4163
c5aa993b
JM
4164 case bp_watchpoint:
4165 case bp_hardware_watchpoint:
4166 case bp_read_watchpoint:
4167 case bp_access_watchpoint:
3a5c3e22
PA
4168 {
4169 struct watchpoint *w = (struct watchpoint *) b;
c906108c 4170
3a5c3e22
PA
4171 /* Likewise for watchpoints on local expressions. */
4172 if (w->exp_valid_block != NULL)
4173 delete_breakpoint (b);
4174 else if (context == inf_starting)
4175 {
4176 /* Reset val field to force reread of starting value in
4177 insert_breakpoints. */
4178 if (w->val)
4179 value_free (w->val);
4180 w->val = NULL;
4181 w->val_valid = 0;
c860120c 4182 }
3a5c3e22 4183 }
c5aa993b
JM
4184 break;
4185 default:
c5aa993b
JM
4186 break;
4187 }
4188 }
1c5cfe86
PA
4189
4190 /* Get rid of the moribund locations. */
35df4500
TJB
4191 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, bl); ++ix)
4192 decref_bp_location (&bl);
1c5cfe86 4193 VEC_free (bp_location_p, moribund_locations);
c906108c
SS
4194}
4195
6c95b8df
PA
4196/* These functions concern about actual breakpoints inserted in the
4197 target --- to e.g. check if we need to do decr_pc adjustment or if
4198 we need to hop over the bkpt --- so we check for address space
4199 match, not program space. */
4200
c2c6d25f
JM
4201/* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4202 exists at PC. It returns ordinary_breakpoint_here if it's an
4203 ordinary breakpoint, or permanent_breakpoint_here if it's a
4204 permanent breakpoint.
4205 - When continuing from a location with an ordinary breakpoint, we
4206 actually single step once before calling insert_breakpoints.
e5dd4106 4207 - When continuing from a location with a permanent breakpoint, we
c2c6d25f
JM
4208 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4209 the target, to advance the PC past the breakpoint. */
c906108c 4210
c2c6d25f 4211enum breakpoint_here
6c95b8df 4212breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
c906108c 4213{
35df4500 4214 struct bp_location *bl, **blp_tmp;
c2c6d25f 4215 int any_breakpoint_here = 0;
c906108c 4216
35df4500 4217 ALL_BP_LOCATIONS (bl, blp_tmp)
075f6582 4218 {
35df4500
TJB
4219 if (bl->loc_type != bp_loc_software_breakpoint
4220 && bl->loc_type != bp_loc_hardware_breakpoint)
075f6582
DJ
4221 continue;
4222
f1310107 4223 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
35df4500 4224 if ((breakpoint_enabled (bl->owner)
1a853c52 4225 || bl->permanent)
f1310107 4226 && breakpoint_location_address_match (bl, aspace, pc))
075f6582
DJ
4227 {
4228 if (overlay_debugging
35df4500
TJB
4229 && section_is_overlay (bl->section)
4230 && !section_is_mapped (bl->section))
075f6582 4231 continue; /* unmapped overlay -- can't be a match */
1a853c52 4232 else if (bl->permanent)
075f6582
DJ
4233 return permanent_breakpoint_here;
4234 else
4235 any_breakpoint_here = 1;
4236 }
4237 }
c906108c 4238
f486487f 4239 return any_breakpoint_here ? ordinary_breakpoint_here : no_breakpoint_here;
c906108c
SS
4240}
4241
1c5cfe86
PA
4242/* Return true if there's a moribund breakpoint at PC. */
4243
4244int
6c95b8df 4245moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
1c5cfe86
PA
4246{
4247 struct bp_location *loc;
4248 int ix;
4249
4250 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
f1310107 4251 if (breakpoint_location_address_match (loc, aspace, pc))
1c5cfe86
PA
4252 return 1;
4253
4254 return 0;
4255}
c2c6d25f 4256
f7ce857f
PA
4257/* Returns non-zero iff BL is inserted at PC, in address space
4258 ASPACE. */
4259
4260static int
4261bp_location_inserted_here_p (struct bp_location *bl,
4262 struct address_space *aspace, CORE_ADDR pc)
4263{
4264 if (bl->inserted
4265 && breakpoint_address_match (bl->pspace->aspace, bl->address,
4266 aspace, pc))
4267 {
4268 if (overlay_debugging
4269 && section_is_overlay (bl->section)
4270 && !section_is_mapped (bl->section))
4271 return 0; /* unmapped overlay -- can't be a match */
4272 else
4273 return 1;
4274 }
4275 return 0;
4276}
4277
a1fd2fa5 4278/* Returns non-zero iff there's a breakpoint inserted at PC. */
c906108c
SS
4279
4280int
a1fd2fa5 4281breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
c906108c 4282{
f7ce857f
PA
4283 struct bp_location **blp, **blp_tmp = NULL;
4284 struct bp_location *bl;
c906108c 4285
f7ce857f 4286 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
c5aa993b 4287 {
f7ce857f
PA
4288 struct bp_location *bl = *blp;
4289
35df4500
TJB
4290 if (bl->loc_type != bp_loc_software_breakpoint
4291 && bl->loc_type != bp_loc_hardware_breakpoint)
075f6582
DJ
4292 continue;
4293
f7ce857f
PA
4294 if (bp_location_inserted_here_p (bl, aspace, pc))
4295 return 1;
c5aa993b 4296 }
c36b740a
VP
4297 return 0;
4298}
4299
a1fd2fa5
PA
4300/* This function returns non-zero iff there is a software breakpoint
4301 inserted at PC. */
c36b740a
VP
4302
4303int
a1fd2fa5
PA
4304software_breakpoint_inserted_here_p (struct address_space *aspace,
4305 CORE_ADDR pc)
4fa8626c 4306{
f7ce857f
PA
4307 struct bp_location **blp, **blp_tmp = NULL;
4308 struct bp_location *bl;
4fa8626c 4309
f7ce857f 4310 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4fa8626c 4311 {
f7ce857f
PA
4312 struct bp_location *bl = *blp;
4313
35df4500 4314 if (bl->loc_type != bp_loc_software_breakpoint)
4fa8626c
DJ
4315 continue;
4316
f7ce857f
PA
4317 if (bp_location_inserted_here_p (bl, aspace, pc))
4318 return 1;
4fa8626c
DJ
4319 }
4320
4321 return 0;
9c02b525
PA
4322}
4323
4324/* See breakpoint.h. */
4325
4326int
4327hardware_breakpoint_inserted_here_p (struct address_space *aspace,
4328 CORE_ADDR pc)
4329{
4330 struct bp_location **blp, **blp_tmp = NULL;
4331 struct bp_location *bl;
4332
4333 ALL_BP_LOCATIONS_AT_ADDR (blp, blp_tmp, pc)
4334 {
4335 struct bp_location *bl = *blp;
4336
4337 if (bl->loc_type != bp_loc_hardware_breakpoint)
4338 continue;
4339
4340 if (bp_location_inserted_here_p (bl, aspace, pc))
4341 return 1;
4342 }
4343
4344 return 0;
4fa8626c
DJ
4345}
4346
9093389c
PA
4347int
4348hardware_watchpoint_inserted_in_range (struct address_space *aspace,
4349 CORE_ADDR addr, ULONGEST len)
4350{
4351 struct breakpoint *bpt;
4352
4353 ALL_BREAKPOINTS (bpt)
4354 {
4355 struct bp_location *loc;
4356
4357 if (bpt->type != bp_hardware_watchpoint
4358 && bpt->type != bp_access_watchpoint)
4359 continue;
4360
4361 if (!breakpoint_enabled (bpt))
4362 continue;
4363
4364 for (loc = bpt->loc; loc; loc = loc->next)
4365 if (loc->pspace->aspace == aspace && loc->inserted)
4366 {
4367 CORE_ADDR l, h;
4368
4369 /* Check for intersection. */
4370 l = max (loc->address, addr);
4371 h = min (loc->address + loc->length, addr + len);
4372 if (l < h)
4373 return 1;
4374 }
4375 }
4376 return 0;
4377}
c906108c 4378\f
c5aa993b 4379
c906108c
SS
4380/* bpstat stuff. External routines' interfaces are documented
4381 in breakpoint.h. */
4382
4383int
c326b90e 4384is_catchpoint (struct breakpoint *ep)
c906108c 4385{
533be4dd 4386 return (ep->type == bp_catchpoint);
c906108c
SS
4387}
4388
f431efe5
PA
4389/* Frees any storage that is part of a bpstat. Does not walk the
4390 'next' chain. */
4391
4392static void
198757a8
VP
4393bpstat_free (bpstat bs)
4394{
4395 if (bs->old_val != NULL)
4396 value_free (bs->old_val);
9add0f1b 4397 decref_counted_command_line (&bs->commands);
f431efe5 4398 decref_bp_location (&bs->bp_location_at);
198757a8
VP
4399 xfree (bs);
4400}
4401
c906108c
SS
4402/* Clear a bpstat so that it says we are not at any breakpoint.
4403 Also free any storage that is part of a bpstat. */
4404
4405void
fba45db2 4406bpstat_clear (bpstat *bsp)
c906108c
SS
4407{
4408 bpstat p;
4409 bpstat q;
4410
4411 if (bsp == 0)
4412 return;
4413 p = *bsp;
4414 while (p != NULL)
4415 {
4416 q = p->next;
198757a8 4417 bpstat_free (p);
c906108c
SS
4418 p = q;
4419 }
4420 *bsp = NULL;
4421}
4422
4423/* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4424 is part of the bpstat is copied as well. */
4425
4426bpstat
fba45db2 4427bpstat_copy (bpstat bs)
c906108c
SS
4428{
4429 bpstat p = NULL;
4430 bpstat tmp;
4431 bpstat retval = NULL;
4432
4433 if (bs == NULL)
4434 return bs;
4435
4436 for (; bs != NULL; bs = bs->next)
4437 {
4438 tmp = (bpstat) xmalloc (sizeof (*tmp));
4439 memcpy (tmp, bs, sizeof (*tmp));
9add0f1b 4440 incref_counted_command_line (tmp->commands);
f431efe5 4441 incref_bp_location (tmp->bp_location_at);
31cc81e9 4442 if (bs->old_val != NULL)
3c3185ac
JK
4443 {
4444 tmp->old_val = value_copy (bs->old_val);
4445 release_value (tmp->old_val);
4446 }
31cc81e9 4447
c906108c
SS
4448 if (p == NULL)
4449 /* This is the first thing in the chain. */
4450 retval = tmp;
4451 else
4452 p->next = tmp;
4453 p = tmp;
4454 }
4455 p->next = NULL;
4456 return retval;
4457}
4458
4a64f543 4459/* Find the bpstat associated with this breakpoint. */
c906108c
SS
4460
4461bpstat
fba45db2 4462bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
c906108c 4463{
c5aa993b
JM
4464 if (bsp == NULL)
4465 return NULL;
c906108c 4466
c5aa993b
JM
4467 for (; bsp != NULL; bsp = bsp->next)
4468 {
f431efe5 4469 if (bsp->breakpoint_at == breakpoint)
c5aa993b
JM
4470 return bsp;
4471 }
c906108c
SS
4472 return NULL;
4473}
4474
ab04a2af
TT
4475/* See breakpoint.h. */
4476
47591c29 4477int
427cd150 4478bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
ab04a2af 4479{
ab04a2af
TT
4480 for (; bsp != NULL; bsp = bsp->next)
4481 {
427cd150
TT
4482 if (bsp->breakpoint_at == NULL)
4483 {
4484 /* A moribund location can never explain a signal other than
4485 GDB_SIGNAL_TRAP. */
4486 if (sig == GDB_SIGNAL_TRAP)
47591c29 4487 return 1;
427cd150
TT
4488 }
4489 else
47591c29
PA
4490 {
4491 if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
4492 sig))
4493 return 1;
4494 }
ab04a2af
TT
4495 }
4496
47591c29 4497 return 0;
ab04a2af
TT
4498}
4499
4a64f543
MS
4500/* Put in *NUM the breakpoint number of the first breakpoint we are
4501 stopped at. *BSP upon return is a bpstat which points to the
4502 remaining breakpoints stopped at (but which is not guaranteed to be
4503 good for anything but further calls to bpstat_num).
4504
8671a17b
PA
4505 Return 0 if passed a bpstat which does not indicate any breakpoints.
4506 Return -1 if stopped at a breakpoint that has been deleted since
4507 we set it.
4508 Return 1 otherwise. */
c906108c
SS
4509
4510int
8671a17b 4511bpstat_num (bpstat *bsp, int *num)
c906108c
SS
4512{
4513 struct breakpoint *b;
4514
4515 if ((*bsp) == NULL)
4516 return 0; /* No more breakpoint values */
8671a17b 4517
4a64f543
MS
4518 /* We assume we'll never have several bpstats that correspond to a
4519 single breakpoint -- otherwise, this function might return the
4520 same number more than once and this will look ugly. */
f431efe5 4521 b = (*bsp)->breakpoint_at;
8671a17b
PA
4522 *bsp = (*bsp)->next;
4523 if (b == NULL)
4524 return -1; /* breakpoint that's been deleted since */
4525
4526 *num = b->number; /* We have its number */
4527 return 1;
c906108c
SS
4528}
4529
e93ca019 4530/* See breakpoint.h. */
c906108c
SS
4531
4532void
e93ca019 4533bpstat_clear_actions (void)
c906108c 4534{
e93ca019
JK
4535 struct thread_info *tp;
4536 bpstat bs;
4537
4538 if (ptid_equal (inferior_ptid, null_ptid))
4539 return;
4540
4541 tp = find_thread_ptid (inferior_ptid);
4542 if (tp == NULL)
4543 return;
4544
4545 for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
c906108c 4546 {
9add0f1b 4547 decref_counted_command_line (&bs->commands);
abf85f46 4548
c906108c
SS
4549 if (bs->old_val != NULL)
4550 {
4551 value_free (bs->old_val);
4552 bs->old_val = NULL;
4553 }
4554 }
4555}
4556
f3b1572e
PA
4557/* Called when a command is about to proceed the inferior. */
4558
4559static void
4560breakpoint_about_to_proceed (void)
4561{
4562 if (!ptid_equal (inferior_ptid, null_ptid))
4563 {
4564 struct thread_info *tp = inferior_thread ();
4565
4566 /* Allow inferior function calls in breakpoint commands to not
4567 interrupt the command list. When the call finishes
4568 successfully, the inferior will be standing at the same
4569 breakpoint as if nothing happened. */
16c381f0 4570 if (tp->control.in_infcall)
f3b1572e
PA
4571 return;
4572 }
4573
4574 breakpoint_proceeded = 1;
4575}
4576
4a64f543
MS
4577/* Stub for cleaning up our state if we error-out of a breakpoint
4578 command. */
c906108c 4579static void
4efb68b1 4580cleanup_executing_breakpoints (void *ignore)
c906108c
SS
4581{
4582 executing_breakpoint_commands = 0;
4583}
4584
abf85f46
JK
4585/* Return non-zero iff CMD as the first line of a command sequence is `silent'
4586 or its equivalent. */
4587
4588static int
4589command_line_is_silent (struct command_line *cmd)
4590{
4f45d445 4591 return cmd && (strcmp ("silent", cmd->line) == 0);
abf85f46
JK
4592}
4593
4a64f543
MS
4594/* Execute all the commands associated with all the breakpoints at
4595 this location. Any of these commands could cause the process to
4596 proceed beyond this point, etc. We look out for such changes by
4597 checking the global "breakpoint_proceeded" after each command.
c906108c 4598
347bddb7
PA
4599 Returns true if a breakpoint command resumed the inferior. In that
4600 case, it is the caller's responsibility to recall it again with the
4601 bpstat of the current thread. */
4602
4603static int
4604bpstat_do_actions_1 (bpstat *bsp)
c906108c
SS
4605{
4606 bpstat bs;
4607 struct cleanup *old_chain;
347bddb7 4608 int again = 0;
c906108c
SS
4609
4610 /* Avoid endless recursion if a `source' command is contained
4611 in bs->commands. */
4612 if (executing_breakpoint_commands)
347bddb7 4613 return 0;
c906108c
SS
4614
4615 executing_breakpoint_commands = 1;
4616 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
4617
cf6c5ffb
TT
4618 prevent_dont_repeat ();
4619
4a64f543 4620 /* This pointer will iterate over the list of bpstat's. */
c906108c
SS
4621 bs = *bsp;
4622
4623 breakpoint_proceeded = 0;
4624 for (; bs != NULL; bs = bs->next)
4625 {
9add0f1b 4626 struct counted_command_line *ccmd;
6c50ab1c
JB
4627 struct command_line *cmd;
4628 struct cleanup *this_cmd_tree_chain;
4629
4630 /* Take ownership of the BSP's command tree, if it has one.
4631
4632 The command tree could legitimately contain commands like
4633 'step' and 'next', which call clear_proceed_status, which
4634 frees stop_bpstat's command tree. To make sure this doesn't
4635 free the tree we're executing out from under us, we need to
4636 take ownership of the tree ourselves. Since a given bpstat's
4637 commands are only executed once, we don't need to copy it; we
4638 can clear the pointer in the bpstat, and make sure we free
4639 the tree when we're done. */
9add0f1b
TT
4640 ccmd = bs->commands;
4641 bs->commands = NULL;
abf85f46
JK
4642 this_cmd_tree_chain = make_cleanup_decref_counted_command_line (&ccmd);
4643 cmd = ccmd ? ccmd->commands : NULL;
4644 if (command_line_is_silent (cmd))
4645 {
4646 /* The action has been already done by bpstat_stop_status. */
4647 cmd = cmd->next;
4648 }
6c50ab1c 4649
c906108c
SS
4650 while (cmd != NULL)
4651 {
4652 execute_control_command (cmd);
4653
4654 if (breakpoint_proceeded)
4655 break;
4656 else
4657 cmd = cmd->next;
4658 }
6c50ab1c
JB
4659
4660 /* We can free this command tree now. */
4661 do_cleanups (this_cmd_tree_chain);
4662
c906108c 4663 if (breakpoint_proceeded)
32c1e744 4664 {
5589af0e 4665 if (interpreter_async && target_can_async_p ())
347bddb7
PA
4666 /* If we are in async mode, then the target might be still
4667 running, not stopped at any breakpoint, so nothing for
4668 us to do here -- just return to the event loop. */
4669 ;
32c1e744
VP
4670 else
4671 /* In sync mode, when execute_control_command returns
4672 we're already standing on the next breakpoint.
347bddb7
PA
4673 Breakpoint commands for that stop were not run, since
4674 execute_command does not run breakpoint commands --
4675 only command_line_handler does, but that one is not
4676 involved in execution of breakpoint commands. So, we
4677 can now execute breakpoint commands. It should be
4678 noted that making execute_command do bpstat actions is
4679 not an option -- in this case we'll have recursive
4680 invocation of bpstat for each breakpoint with a
4681 command, and can easily blow up GDB stack. Instead, we
4682 return true, which will trigger the caller to recall us
4683 with the new stop_bpstat. */
4684 again = 1;
4685 break;
32c1e744 4686 }
c906108c 4687 }
c2b8ed2c 4688 do_cleanups (old_chain);
347bddb7
PA
4689 return again;
4690}
4691
4692void
4693bpstat_do_actions (void)
4694{
353d1d73
JK
4695 struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
4696
347bddb7
PA
4697 /* Do any commands attached to breakpoint we are stopped at. */
4698 while (!ptid_equal (inferior_ptid, null_ptid)
4699 && target_has_execution
4700 && !is_exited (inferior_ptid)
4701 && !is_executing (inferior_ptid))
4702 /* Since in sync mode, bpstat_do_actions may resume the inferior,
4703 and only return when it is stopped at the next breakpoint, we
4704 keep doing breakpoint actions until it returns false to
4705 indicate the inferior was not resumed. */
16c381f0 4706 if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
347bddb7 4707 break;
353d1d73
JK
4708
4709 discard_cleanups (cleanup_if_error);
c906108c
SS
4710}
4711
fa4727a6
DJ
4712/* Print out the (old or new) value associated with a watchpoint. */
4713
4714static void
4715watchpoint_value_print (struct value *val, struct ui_file *stream)
4716{
4717 if (val == NULL)
4718 fprintf_unfiltered (stream, _("<unreadable>"));
4719 else
79a45b7d
TT
4720 {
4721 struct value_print_options opts;
4722 get_user_print_options (&opts);
4723 value_print (val, stream, &opts);
4724 }
fa4727a6
DJ
4725}
4726
e514a9d6 4727/* Generic routine for printing messages indicating why we
4a64f543 4728 stopped. The behavior of this function depends on the value
e514a9d6
JM
4729 'print_it' in the bpstat structure. Under some circumstances we
4730 may decide not to print anything here and delegate the task to
4a64f543 4731 normal_stop(). */
e514a9d6
JM
4732
4733static enum print_stop_action
4734print_bp_stop_message (bpstat bs)
4735{
4736 switch (bs->print_it)
4737 {
4738 case print_it_noop:
4a64f543 4739 /* Nothing should be printed for this bpstat entry. */
e514a9d6
JM
4740 return PRINT_UNKNOWN;
4741 break;
4742
4743 case print_it_done:
4744 /* We still want to print the frame, but we already printed the
4a64f543 4745 relevant messages. */
e514a9d6
JM
4746 return PRINT_SRC_AND_LOC;
4747 break;
4748
4749 case print_it_normal:
4f8d1dc6 4750 {
f431efe5
PA
4751 struct breakpoint *b = bs->breakpoint_at;
4752
1a6a67de
TJB
4753 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4754 which has since been deleted. */
4755 if (b == NULL)
4756 return PRINT_UNKNOWN;
4757
348d480f
PA
4758 /* Normal case. Call the breakpoint's print_it method. */
4759 return b->ops->print_it (bs);
4f8d1dc6 4760 }
348d480f 4761 break;
3086aeae 4762
e514a9d6 4763 default:
8e65ff28 4764 internal_error (__FILE__, __LINE__,
e2e0b3e5 4765 _("print_bp_stop_message: unrecognized enum value"));
e514a9d6 4766 break;
c906108c 4767 }
c906108c
SS
4768}
4769
edcc5120
TT
4770/* A helper function that prints a shared library stopped event. */
4771
4772static void
4773print_solib_event (int is_catchpoint)
4774{
4775 int any_deleted
4776 = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
4777 int any_added
4778 = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
4779
4780 if (!is_catchpoint)
4781 {
4782 if (any_added || any_deleted)
4783 ui_out_text (current_uiout,
4784 _("Stopped due to shared library event:\n"));
4785 else
4786 ui_out_text (current_uiout,
4787 _("Stopped due to shared library event (no "
4788 "libraries added or removed)\n"));
4789 }
4790
4791 if (ui_out_is_mi_like_p (current_uiout))
4792 ui_out_field_string (current_uiout, "reason",
4793 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
4794
4795 if (any_deleted)
4796 {
4797 struct cleanup *cleanup;
4798 char *name;
4799 int ix;
4800
4801 ui_out_text (current_uiout, _(" Inferior unloaded "));
4802 cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4803 "removed");
4804 for (ix = 0;
4805 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
4806 ix, name);
4807 ++ix)
4808 {
4809 if (ix > 0)
4810 ui_out_text (current_uiout, " ");
4811 ui_out_field_string (current_uiout, "library", name);
4812 ui_out_text (current_uiout, "\n");
4813 }
4814
4815 do_cleanups (cleanup);
4816 }
4817
4818 if (any_added)
4819 {
4820 struct so_list *iter;
4821 int ix;
4822 struct cleanup *cleanup;
4823
4824 ui_out_text (current_uiout, _(" Inferior loaded "));
4825 cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
4826 "added");
4827 for (ix = 0;
4828 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
4829 ix, iter);
4830 ++ix)
4831 {
4832 if (ix > 0)
4833 ui_out_text (current_uiout, " ");
4834 ui_out_field_string (current_uiout, "library", iter->so_name);
4835 ui_out_text (current_uiout, "\n");
4836 }
4837
4838 do_cleanups (cleanup);
4839 }
4840}
4841
e514a9d6
JM
4842/* Print a message indicating what happened. This is called from
4843 normal_stop(). The input to this routine is the head of the bpstat
36dfb11c
TT
4844 list - a list of the eventpoints that caused this stop. KIND is
4845 the target_waitkind for the stopping event. This
e514a9d6
JM
4846 routine calls the generic print routine for printing a message
4847 about reasons for stopping. This will print (for example) the
4848 "Breakpoint n," part of the output. The return value of this
4849 routine is one of:
c906108c 4850
4a64f543 4851 PRINT_UNKNOWN: Means we printed nothing.
917317f4 4852 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4a64f543 4853 code to print the location. An example is
c5aa993b
JM
4854 "Breakpoint 1, " which should be followed by
4855 the location.
917317f4 4856 PRINT_SRC_ONLY: Means we printed something, but there is no need
c5aa993b
JM
4857 to also print the location part of the message.
4858 An example is the catch/throw messages, which
4a64f543 4859 don't require a location appended to the end.
917317f4 4860 PRINT_NOTHING: We have done some printing and we don't need any
4a64f543 4861 further info to be printed. */
c906108c 4862
917317f4 4863enum print_stop_action
36dfb11c 4864bpstat_print (bpstat bs, int kind)
c906108c 4865{
f486487f 4866 enum print_stop_action val;
c5aa993b 4867
c906108c 4868 /* Maybe another breakpoint in the chain caused us to stop.
53a5351d
JM
4869 (Currently all watchpoints go on the bpstat whether hit or not.
4870 That probably could (should) be changed, provided care is taken
c906108c 4871 with respect to bpstat_explains_signal). */
e514a9d6
JM
4872 for (; bs; bs = bs->next)
4873 {
4874 val = print_bp_stop_message (bs);
4875 if (val == PRINT_SRC_ONLY
4876 || val == PRINT_SRC_AND_LOC
4877 || val == PRINT_NOTHING)
4878 return val;
4879 }
c906108c 4880
36dfb11c
TT
4881 /* If we had hit a shared library event breakpoint,
4882 print_bp_stop_message would print out this message. If we hit an
4883 OS-level shared library event, do the same thing. */
4884 if (kind == TARGET_WAITKIND_LOADED)
4885 {
edcc5120 4886 print_solib_event (0);
36dfb11c
TT
4887 return PRINT_NOTHING;
4888 }
4889
e514a9d6 4890 /* We reached the end of the chain, or we got a null BS to start
4a64f543 4891 with and nothing was printed. */
917317f4 4892 return PRINT_UNKNOWN;
c906108c
SS
4893}
4894
c42bd95a
DE
4895/* Evaluate the expression EXP and return 1 if value is zero.
4896 This returns the inverse of the condition because it is called
4897 from catch_errors which returns 0 if an exception happened, and if an
4898 exception happens we want execution to stop.
4a64f543 4899 The argument is a "struct expression *" that has been cast to a
c42bd95a 4900 "void *" to make it pass through catch_errors. */
c906108c
SS
4901
4902static int
4efb68b1 4903breakpoint_cond_eval (void *exp)
c906108c 4904{
278cd55f 4905 struct value *mark = value_mark ();
c5aa993b 4906 int i = !value_true (evaluate_expression ((struct expression *) exp));
cc59ec59 4907
c906108c
SS
4908 value_free_to_mark (mark);
4909 return i;
4910}
4911
5760d0ab 4912/* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
c906108c
SS
4913
4914static bpstat
5760d0ab 4915bpstat_alloc (struct bp_location *bl, bpstat **bs_link_pointer)
c906108c
SS
4916{
4917 bpstat bs;
4918
4919 bs = (bpstat) xmalloc (sizeof (*bs));
5760d0ab
JK
4920 bs->next = NULL;
4921 **bs_link_pointer = bs;
4922 *bs_link_pointer = &bs->next;
f431efe5
PA
4923 bs->breakpoint_at = bl->owner;
4924 bs->bp_location_at = bl;
4925 incref_bp_location (bl);
c906108c
SS
4926 /* If the condition is false, etc., don't do the commands. */
4927 bs->commands = NULL;
4928 bs->old_val = NULL;
4929 bs->print_it = print_it_normal;
4930 return bs;
4931}
4932\f
d983da9c
DJ
4933/* The target has stopped with waitstatus WS. Check if any hardware
4934 watchpoints have triggered, according to the target. */
4935
4936int
4937watchpoints_triggered (struct target_waitstatus *ws)
4938{
d92524f1 4939 int stopped_by_watchpoint = target_stopped_by_watchpoint ();
d983da9c
DJ
4940 CORE_ADDR addr;
4941 struct breakpoint *b;
4942
4943 if (!stopped_by_watchpoint)
4944 {
4945 /* We were not stopped by a watchpoint. Mark all watchpoints
4946 as not triggered. */
4947 ALL_BREAKPOINTS (b)
cc60f2e3 4948 if (is_hardware_watchpoint (b))
3a5c3e22
PA
4949 {
4950 struct watchpoint *w = (struct watchpoint *) b;
4951
4952 w->watchpoint_triggered = watch_triggered_no;
4953 }
d983da9c
DJ
4954
4955 return 0;
4956 }
4957
4958 if (!target_stopped_data_address (&current_target, &addr))
4959 {
4960 /* We were stopped by a watchpoint, but we don't know where.
4961 Mark all watchpoints as unknown. */
4962 ALL_BREAKPOINTS (b)
cc60f2e3 4963 if (is_hardware_watchpoint (b))
3a5c3e22
PA
4964 {
4965 struct watchpoint *w = (struct watchpoint *) b;
4966
4967 w->watchpoint_triggered = watch_triggered_unknown;
4968 }
d983da9c 4969
3c4797ba 4970 return 1;
d983da9c
DJ
4971 }
4972
4973 /* The target could report the data address. Mark watchpoints
4974 affected by this data address as triggered, and all others as not
4975 triggered. */
4976
4977 ALL_BREAKPOINTS (b)
cc60f2e3 4978 if (is_hardware_watchpoint (b))
d983da9c 4979 {
3a5c3e22 4980 struct watchpoint *w = (struct watchpoint *) b;
a5606eee 4981 struct bp_location *loc;
d983da9c 4982
3a5c3e22 4983 w->watchpoint_triggered = watch_triggered_no;
a5606eee 4984 for (loc = b->loc; loc; loc = loc->next)
9c06b0b4 4985 {
3a5c3e22 4986 if (is_masked_watchpoint (b))
9c06b0b4 4987 {
3a5c3e22
PA
4988 CORE_ADDR newaddr = addr & w->hw_wp_mask;
4989 CORE_ADDR start = loc->address & w->hw_wp_mask;
9c06b0b4
TJB
4990
4991 if (newaddr == start)
4992 {
3a5c3e22 4993 w->watchpoint_triggered = watch_triggered_yes;
9c06b0b4
TJB
4994 break;
4995 }
4996 }
4997 /* Exact match not required. Within range is sufficient. */
4998 else if (target_watchpoint_addr_within_range (&current_target,
4999 addr, loc->address,
5000 loc->length))
5001 {
3a5c3e22 5002 w->watchpoint_triggered = watch_triggered_yes;
9c06b0b4
TJB
5003 break;
5004 }
5005 }
d983da9c
DJ
5006 }
5007
5008 return 1;
5009}
5010
c906108c
SS
5011/* Possible return values for watchpoint_check (this can't be an enum
5012 because of check_errors). */
5013/* The watchpoint has been deleted. */
5014#define WP_DELETED 1
5015/* The value has changed. */
5016#define WP_VALUE_CHANGED 2
5017/* The value has not changed. */
5018#define WP_VALUE_NOT_CHANGED 3
60e1c644
PA
5019/* Ignore this watchpoint, no matter if the value changed or not. */
5020#define WP_IGNORE 4
c906108c
SS
5021
5022#define BP_TEMPFLAG 1
5023#define BP_HARDWAREFLAG 2
5024
4a64f543
MS
5025/* Evaluate watchpoint condition expression and check if its value
5026 changed.
553e4c11
JB
5027
5028 P should be a pointer to struct bpstat, but is defined as a void *
5029 in order for this function to be usable with catch_errors. */
c906108c
SS
5030
5031static int
4efb68b1 5032watchpoint_check (void *p)
c906108c
SS
5033{
5034 bpstat bs = (bpstat) p;
3a5c3e22 5035 struct watchpoint *b;
c906108c
SS
5036 struct frame_info *fr;
5037 int within_current_scope;
5038
f431efe5 5039 /* BS is built from an existing struct breakpoint. */
2bdf28a0 5040 gdb_assert (bs->breakpoint_at != NULL);
3a5c3e22 5041 b = (struct watchpoint *) bs->breakpoint_at;
d0fb5eae 5042
f6bc2008
PA
5043 /* If this is a local watchpoint, we only want to check if the
5044 watchpoint frame is in scope if the current thread is the thread
5045 that was used to create the watchpoint. */
5046 if (!watchpoint_in_thread_scope (b))
60e1c644 5047 return WP_IGNORE;
f6bc2008 5048
c906108c
SS
5049 if (b->exp_valid_block == NULL)
5050 within_current_scope = 1;
5051 else
5052 {
edb3359d
DJ
5053 struct frame_info *frame = get_current_frame ();
5054 struct gdbarch *frame_arch = get_frame_arch (frame);
5055 CORE_ADDR frame_pc = get_frame_pc (frame);
5056
c9cf6e20 5057 /* stack_frame_destroyed_p() returns a non-zero value if we're
4a64f543
MS
5058 still in the function but the stack frame has already been
5059 invalidated. Since we can't rely on the values of local
5060 variables after the stack has been destroyed, we are treating
5061 the watchpoint in that state as `not changed' without further
5062 checking. Don't mark watchpoints as changed if the current
5063 frame is in an epilogue - even if they are in some other
5064 frame, our view of the stack is likely to be wrong and
5065 frame_find_by_id could error out. */
c9cf6e20 5066 if (gdbarch_stack_frame_destroyed_p (frame_arch, frame_pc))
60e1c644 5067 return WP_IGNORE;
a0f49112 5068
101dcfbe 5069 fr = frame_find_by_id (b->watchpoint_frame);
c906108c 5070 within_current_scope = (fr != NULL);
69fbadd5
DJ
5071
5072 /* If we've gotten confused in the unwinder, we might have
5073 returned a frame that can't describe this variable. */
edb3359d
DJ
5074 if (within_current_scope)
5075 {
5076 struct symbol *function;
5077
5078 function = get_frame_function (fr);
5079 if (function == NULL
5080 || !contained_in (b->exp_valid_block,
5081 SYMBOL_BLOCK_VALUE (function)))
5082 within_current_scope = 0;
5083 }
69fbadd5 5084
edb3359d 5085 if (within_current_scope)
c906108c
SS
5086 /* If we end up stopping, the current frame will get selected
5087 in normal_stop. So this call to select_frame won't affect
5088 the user. */
0f7d239c 5089 select_frame (fr);
c906108c 5090 }
c5aa993b 5091
c906108c
SS
5092 if (within_current_scope)
5093 {
4a64f543
MS
5094 /* We use value_{,free_to_}mark because it could be a *long*
5095 time before we return to the command level and call
5096 free_all_values. We can't call free_all_values because we
5097 might be in the middle of evaluating a function call. */
c906108c 5098
0cf6dd15 5099 int pc = 0;
9c06b0b4 5100 struct value *mark;
fa4727a6
DJ
5101 struct value *new_val;
5102
3a5c3e22 5103 if (is_masked_watchpoint (&b->base))
9c06b0b4
TJB
5104 /* Since we don't know the exact trigger address (from
5105 stopped_data_address), just tell the user we've triggered
5106 a mask watchpoint. */
5107 return WP_VALUE_CHANGED;
5108
5109 mark = value_mark ();
3a1115a0 5110 fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL, 0);
218d2fc6 5111
bb9d5f81
PP
5112 if (b->val_bitsize != 0)
5113 new_val = extract_bitfield_from_watchpoint_value (b, new_val);
5114
4a64f543
MS
5115 /* We use value_equal_contents instead of value_equal because
5116 the latter coerces an array to a pointer, thus comparing just
5117 the address of the array instead of its contents. This is
5118 not what we want. */
fa4727a6 5119 if ((b->val != NULL) != (new_val != NULL)
218d2fc6 5120 || (b->val != NULL && !value_equal_contents (b->val, new_val)))
c906108c 5121 {
fa4727a6
DJ
5122 if (new_val != NULL)
5123 {
5124 release_value (new_val);
5125 value_free_to_mark (mark);
5126 }
c906108c
SS
5127 bs->old_val = b->val;
5128 b->val = new_val;
fa4727a6 5129 b->val_valid = 1;
c906108c
SS
5130 return WP_VALUE_CHANGED;
5131 }
5132 else
5133 {
60e1c644 5134 /* Nothing changed. */
c906108c 5135 value_free_to_mark (mark);
c906108c
SS
5136 return WP_VALUE_NOT_CHANGED;
5137 }
5138 }
5139 else
5140 {
79a45e25
PA
5141 struct ui_out *uiout = current_uiout;
5142
c906108c 5143 /* This seems like the only logical thing to do because
c5aa993b
JM
5144 if we temporarily ignored the watchpoint, then when
5145 we reenter the block in which it is valid it contains
5146 garbage (in the case of a function, it may have two
5147 garbage values, one before and one after the prologue).
5148 So we can't even detect the first assignment to it and
5149 watch after that (since the garbage may or may not equal
5150 the first value assigned). */
348d480f
PA
5151 /* We print all the stop information in
5152 breakpoint_ops->print_it, but in this case, by the time we
5153 call breakpoint_ops->print_it this bp will be deleted
5154 already. So we have no choice but print the information
5155 here. */
9dc5e2a9 5156 if (ui_out_is_mi_like_p (uiout))
034dad6f
BR
5157 ui_out_field_string
5158 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
8b93c638 5159 ui_out_text (uiout, "\nWatchpoint ");
3a5c3e22 5160 ui_out_field_int (uiout, "wpnum", b->base.number);
3e43a32a
MS
5161 ui_out_text (uiout,
5162 " deleted because the program has left the block in\n\
8b93c638 5163which its expression is valid.\n");
4ce44c66 5164
cdac0397 5165 /* Make sure the watchpoint's commands aren't executed. */
3a5c3e22 5166 decref_counted_command_line (&b->base.commands);
d0fb5eae 5167 watchpoint_del_at_next_stop (b);
c906108c
SS
5168
5169 return WP_DELETED;
5170 }
5171}
5172
18a18393 5173/* Return true if it looks like target has stopped due to hitting
348d480f
PA
5174 breakpoint location BL. This function does not check if we should
5175 stop, only if BL explains the stop. */
5176
18a18393 5177static int
6c95b8df 5178bpstat_check_location (const struct bp_location *bl,
09ac7c10
TT
5179 struct address_space *aspace, CORE_ADDR bp_addr,
5180 const struct target_waitstatus *ws)
18a18393
VP
5181{
5182 struct breakpoint *b = bl->owner;
5183
348d480f 5184 /* BL is from an existing breakpoint. */
2bdf28a0
JK
5185 gdb_assert (b != NULL);
5186
09ac7c10 5187 return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
18a18393
VP
5188}
5189
3a5c3e22
PA
5190/* Determine if the watched values have actually changed, and we
5191 should stop. If not, set BS->stop to 0. */
5192
18a18393
VP
5193static void
5194bpstat_check_watchpoint (bpstat bs)
5195{
2bdf28a0 5196 const struct bp_location *bl;
3a5c3e22 5197 struct watchpoint *b;
2bdf28a0
JK
5198
5199 /* BS is built for existing struct breakpoint. */
f431efe5 5200 bl = bs->bp_location_at;
2bdf28a0 5201 gdb_assert (bl != NULL);
3a5c3e22 5202 b = (struct watchpoint *) bs->breakpoint_at;
2bdf28a0 5203 gdb_assert (b != NULL);
18a18393 5204
18a18393 5205 {
18a18393
VP
5206 int must_check_value = 0;
5207
3a5c3e22 5208 if (b->base.type == bp_watchpoint)
18a18393
VP
5209 /* For a software watchpoint, we must always check the
5210 watched value. */
5211 must_check_value = 1;
5212 else if (b->watchpoint_triggered == watch_triggered_yes)
5213 /* We have a hardware watchpoint (read, write, or access)
5214 and the target earlier reported an address watched by
5215 this watchpoint. */
5216 must_check_value = 1;
5217 else if (b->watchpoint_triggered == watch_triggered_unknown
3a5c3e22 5218 && b->base.type == bp_hardware_watchpoint)
18a18393
VP
5219 /* We were stopped by a hardware watchpoint, but the target could
5220 not report the data address. We must check the watchpoint's
5221 value. Access and read watchpoints are out of luck; without
5222 a data address, we can't figure it out. */
5223 must_check_value = 1;
3a5c3e22 5224
18a18393
VP
5225 if (must_check_value)
5226 {
3e43a32a
MS
5227 char *message
5228 = xstrprintf ("Error evaluating expression for watchpoint %d\n",
3a5c3e22 5229 b->base.number);
18a18393
VP
5230 struct cleanup *cleanups = make_cleanup (xfree, message);
5231 int e = catch_errors (watchpoint_check, bs, message,
5232 RETURN_MASK_ALL);
5233 do_cleanups (cleanups);
5234 switch (e)
5235 {
5236 case WP_DELETED:
5237 /* We've already printed what needs to be printed. */
5238 bs->print_it = print_it_done;
5239 /* Stop. */
5240 break;
60e1c644
PA
5241 case WP_IGNORE:
5242 bs->print_it = print_it_noop;
5243 bs->stop = 0;
5244 break;
18a18393 5245 case WP_VALUE_CHANGED:
3a5c3e22 5246 if (b->base.type == bp_read_watchpoint)
18a18393 5247 {
85d721b8
PA
5248 /* There are two cases to consider here:
5249
4a64f543 5250 1. We're watching the triggered memory for reads.
85d721b8
PA
5251 In that case, trust the target, and always report
5252 the watchpoint hit to the user. Even though
5253 reads don't cause value changes, the value may
5254 have changed since the last time it was read, and
5255 since we're not trapping writes, we will not see
5256 those, and as such we should ignore our notion of
5257 old value.
5258
4a64f543 5259 2. We're watching the triggered memory for both
85d721b8
PA
5260 reads and writes. There are two ways this may
5261 happen:
5262
4a64f543 5263 2.1. This is a target that can't break on data
85d721b8
PA
5264 reads only, but can break on accesses (reads or
5265 writes), such as e.g., x86. We detect this case
5266 at the time we try to insert read watchpoints.
5267
4a64f543 5268 2.2. Otherwise, the target supports read
85d721b8
PA
5269 watchpoints, but, the user set an access or write
5270 watchpoint watching the same memory as this read
5271 watchpoint.
5272
5273 If we're watching memory writes as well as reads,
5274 ignore watchpoint hits when we find that the
5275 value hasn't changed, as reads don't cause
5276 changes. This still gives false positives when
5277 the program writes the same value to memory as
5278 what there was already in memory (we will confuse
5279 it for a read), but it's much better than
5280 nothing. */
5281
5282 int other_write_watchpoint = 0;
5283
5284 if (bl->watchpoint_type == hw_read)
5285 {
5286 struct breakpoint *other_b;
5287
5288 ALL_BREAKPOINTS (other_b)
3a5c3e22
PA
5289 if (other_b->type == bp_hardware_watchpoint
5290 || other_b->type == bp_access_watchpoint)
85d721b8 5291 {
3a5c3e22
PA
5292 struct watchpoint *other_w =
5293 (struct watchpoint *) other_b;
5294
5295 if (other_w->watchpoint_triggered
5296 == watch_triggered_yes)
5297 {
5298 other_write_watchpoint = 1;
5299 break;
5300 }
85d721b8
PA
5301 }
5302 }
5303
5304 if (other_write_watchpoint
5305 || bl->watchpoint_type == hw_access)
5306 {
5307 /* We're watching the same memory for writes,
5308 and the value changed since the last time we
5309 updated it, so this trap must be for a write.
5310 Ignore it. */
5311 bs->print_it = print_it_noop;
5312 bs->stop = 0;
5313 }
18a18393
VP
5314 }
5315 break;
5316 case WP_VALUE_NOT_CHANGED:
3a5c3e22
PA
5317 if (b->base.type == bp_hardware_watchpoint
5318 || b->base.type == bp_watchpoint)
18a18393
VP
5319 {
5320 /* Don't stop: write watchpoints shouldn't fire if
5321 the value hasn't changed. */
5322 bs->print_it = print_it_noop;
5323 bs->stop = 0;
5324 }
5325 /* Stop. */
5326 break;
5327 default:
5328 /* Can't happen. */
5329 case 0:
5330 /* Error from catch_errors. */
3a5c3e22 5331 printf_filtered (_("Watchpoint %d deleted.\n"), b->base.number);
d0fb5eae 5332 watchpoint_del_at_next_stop (b);
18a18393
VP
5333 /* We've already printed what needs to be printed. */
5334 bs->print_it = print_it_done;
5335 break;
5336 }
5337 }
5338 else /* must_check_value == 0 */
5339 {
5340 /* This is a case where some watchpoint(s) triggered, but
5341 not at the address of this watchpoint, or else no
5342 watchpoint triggered after all. So don't print
5343 anything for this watchpoint. */
5344 bs->print_it = print_it_noop;
5345 bs->stop = 0;
5346 }
5347 }
5348}
5349
7d4df6a4
DE
5350/* For breakpoints that are currently marked as telling gdb to stop,
5351 check conditions (condition proper, frame, thread and ignore count)
18a18393
VP
5352 of breakpoint referred to by BS. If we should not stop for this
5353 breakpoint, set BS->stop to 0. */
f431efe5 5354
18a18393
VP
5355static void
5356bpstat_check_breakpoint_conditions (bpstat bs, ptid_t ptid)
5357{
2bdf28a0
JK
5358 const struct bp_location *bl;
5359 struct breakpoint *b;
7d4df6a4
DE
5360 int value_is_zero = 0;
5361 struct expression *cond;
5362
5363 gdb_assert (bs->stop);
2bdf28a0
JK
5364
5365 /* BS is built for existing struct breakpoint. */
f431efe5 5366 bl = bs->bp_location_at;
2bdf28a0 5367 gdb_assert (bl != NULL);
f431efe5 5368 b = bs->breakpoint_at;
2bdf28a0 5369 gdb_assert (b != NULL);
18a18393 5370
b775012e
LM
5371 /* Even if the target evaluated the condition on its end and notified GDB, we
5372 need to do so again since GDB does not know if we stopped due to a
5373 breakpoint or a single step breakpoint. */
5374
18a18393 5375 if (frame_id_p (b->frame_id)
edb3359d 5376 && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
18a18393 5377 {
7d4df6a4
DE
5378 bs->stop = 0;
5379 return;
5380 }
60e1c644 5381
12ab52e9
PA
5382 /* If this is a thread/task-specific breakpoint, don't waste cpu
5383 evaluating the condition if this isn't the specified
5384 thread/task. */
5385 if ((b->thread != -1 && b->thread != pid_to_thread_id (ptid))
5386 || (b->task != 0 && b->task != ada_get_task_number (ptid)))
5387
6c1b0f7b
DE
5388 {
5389 bs->stop = 0;
5390 return;
5391 }
5392
6dddc817
DE
5393 /* Evaluate extension language breakpoints that have a "stop" method
5394 implemented. */
5395 bs->stop = breakpoint_ext_lang_cond_says_stop (b);
7371cf6d 5396
7d4df6a4
DE
5397 if (is_watchpoint (b))
5398 {
5399 struct watchpoint *w = (struct watchpoint *) b;
3a5c3e22 5400
7d4df6a4
DE
5401 cond = w->cond_exp;
5402 }
5403 else
5404 cond = bl->cond;
60e1c644 5405
7d4df6a4
DE
5406 if (cond && b->disposition != disp_del_at_next_stop)
5407 {
5408 int within_current_scope = 1;
5409 struct watchpoint * w;
60e1c644 5410
7d4df6a4
DE
5411 /* We use value_mark and value_free_to_mark because it could
5412 be a long time before we return to the command level and
5413 call free_all_values. We can't call free_all_values
5414 because we might be in the middle of evaluating a
5415 function call. */
5416 struct value *mark = value_mark ();
5417
5418 if (is_watchpoint (b))
5419 w = (struct watchpoint *) b;
5420 else
5421 w = NULL;
5422
5423 /* Need to select the frame, with all that implies so that
5424 the conditions will have the right context. Because we
5425 use the frame, we will not see an inlined function's
5426 variables when we arrive at a breakpoint at the start
5427 of the inlined function; the current frame will be the
5428 call site. */
5429 if (w == NULL || w->cond_exp_valid_block == NULL)
5430 select_frame (get_current_frame ());
5431 else
18a18393 5432 {
7d4df6a4
DE
5433 struct frame_info *frame;
5434
5435 /* For local watchpoint expressions, which particular
5436 instance of a local is being watched matters, so we
5437 keep track of the frame to evaluate the expression
5438 in. To evaluate the condition however, it doesn't
5439 really matter which instantiation of the function
5440 where the condition makes sense triggers the
5441 watchpoint. This allows an expression like "watch
5442 global if q > 10" set in `func', catch writes to
5443 global on all threads that call `func', or catch
5444 writes on all recursive calls of `func' by a single
5445 thread. We simply always evaluate the condition in
5446 the innermost frame that's executing where it makes
5447 sense to evaluate the condition. It seems
5448 intuitive. */
5449 frame = block_innermost_frame (w->cond_exp_valid_block);
5450 if (frame != NULL)
5451 select_frame (frame);
5452 else
5453 within_current_scope = 0;
18a18393 5454 }
7d4df6a4
DE
5455 if (within_current_scope)
5456 value_is_zero
5457 = catch_errors (breakpoint_cond_eval, cond,
5458 "Error in testing breakpoint condition:\n",
5459 RETURN_MASK_ALL);
5460 else
18a18393 5461 {
7d4df6a4
DE
5462 warning (_("Watchpoint condition cannot be tested "
5463 "in the current scope"));
5464 /* If we failed to set the right context for this
5465 watchpoint, unconditionally report it. */
5466 value_is_zero = 0;
18a18393 5467 }
7d4df6a4
DE
5468 /* FIXME-someday, should give breakpoint #. */
5469 value_free_to_mark (mark);
18a18393 5470 }
7d4df6a4
DE
5471
5472 if (cond && value_is_zero)
5473 {
5474 bs->stop = 0;
5475 }
7d4df6a4
DE
5476 else if (b->ignore_count > 0)
5477 {
5478 b->ignore_count--;
5479 bs->stop = 0;
5480 /* Increase the hit count even though we don't stop. */
5481 ++(b->hit_count);
5482 observer_notify_breakpoint_modified (b);
5483 }
18a18393
VP
5484}
5485
1cf4d951
PA
5486/* Returns true if we need to track moribund locations of LOC's type
5487 on the current target. */
5488
5489static int
5490need_moribund_for_location_type (struct bp_location *loc)
5491{
5492 return ((loc->loc_type == bp_loc_software_breakpoint
5493 && !target_supports_stopped_by_sw_breakpoint ())
5494 || (loc->loc_type == bp_loc_hardware_breakpoint
5495 && !target_supports_stopped_by_hw_breakpoint ()));
5496}
5497
18a18393 5498
9709f61c 5499/* Get a bpstat associated with having just stopped at address
d983da9c 5500 BP_ADDR in thread PTID.
c906108c 5501
d983da9c 5502 Determine whether we stopped at a breakpoint, etc, or whether we
4a64f543
MS
5503 don't understand this stop. Result is a chain of bpstat's such
5504 that:
c906108c 5505
c5aa993b 5506 if we don't understand the stop, the result is a null pointer.
c906108c 5507
c5aa993b 5508 if we understand why we stopped, the result is not null.
c906108c 5509
c5aa993b
JM
5510 Each element of the chain refers to a particular breakpoint or
5511 watchpoint at which we have stopped. (We may have stopped for
5512 several reasons concurrently.)
c906108c 5513
c5aa993b
JM
5514 Each element of the chain has valid next, breakpoint_at,
5515 commands, FIXME??? fields. */
c906108c
SS
5516
5517bpstat
6c95b8df 5518bpstat_stop_status (struct address_space *aspace,
09ac7c10
TT
5519 CORE_ADDR bp_addr, ptid_t ptid,
5520 const struct target_waitstatus *ws)
c906108c 5521{
0d381245 5522 struct breakpoint *b = NULL;
afe38095 5523 struct bp_location *bl;
20874c92 5524 struct bp_location *loc;
5760d0ab
JK
5525 /* First item of allocated bpstat's. */
5526 bpstat bs_head = NULL, *bs_link = &bs_head;
c906108c 5527 /* Pointer to the last thing in the chain currently. */
5760d0ab 5528 bpstat bs;
20874c92 5529 int ix;
429374b8 5530 int need_remove_insert;
f431efe5 5531 int removed_any;
c906108c 5532
f431efe5
PA
5533 /* First, build the bpstat chain with locations that explain a
5534 target stop, while being careful to not set the target running,
5535 as that may invalidate locations (in particular watchpoint
5536 locations are recreated). Resuming will happen here with
5537 breakpoint conditions or watchpoint expressions that include
5538 inferior function calls. */
c5aa993b 5539
429374b8
JK
5540 ALL_BREAKPOINTS (b)
5541 {
1a853c52 5542 if (!breakpoint_enabled (b))
429374b8 5543 continue;
a5606eee 5544
429374b8
JK
5545 for (bl = b->loc; bl != NULL; bl = bl->next)
5546 {
4a64f543
MS
5547 /* For hardware watchpoints, we look only at the first
5548 location. The watchpoint_check function will work on the
5549 entire expression, not the individual locations. For
5550 read watchpoints, the watchpoints_triggered function has
5551 checked all locations already. */
429374b8
JK
5552 if (b->type == bp_hardware_watchpoint && bl != b->loc)
5553 break;
18a18393 5554
f6592439 5555 if (!bl->enabled || bl->shlib_disabled)
429374b8 5556 continue;
c5aa993b 5557
09ac7c10 5558 if (!bpstat_check_location (bl, aspace, bp_addr, ws))
429374b8 5559 continue;
c5aa993b 5560
4a64f543
MS
5561 /* Come here if it's a watchpoint, or if the break address
5562 matches. */
c5aa993b 5563
4a64f543
MS
5564 bs = bpstat_alloc (bl, &bs_link); /* Alloc a bpstat to
5565 explain stop. */
c5aa993b 5566
f431efe5
PA
5567 /* Assume we stop. Should we find a watchpoint that is not
5568 actually triggered, or if the condition of the breakpoint
5569 evaluates as false, we'll reset 'stop' to 0. */
429374b8
JK
5570 bs->stop = 1;
5571 bs->print = 1;
d983da9c 5572
f431efe5
PA
5573 /* If this is a scope breakpoint, mark the associated
5574 watchpoint as triggered so that we will handle the
5575 out-of-scope event. We'll get to the watchpoint next
5576 iteration. */
d0fb5eae 5577 if (b->type == bp_watchpoint_scope && b->related_breakpoint != b)
3a5c3e22
PA
5578 {
5579 struct watchpoint *w = (struct watchpoint *) b->related_breakpoint;
5580
5581 w->watchpoint_triggered = watch_triggered_yes;
5582 }
f431efe5
PA
5583 }
5584 }
5585
7c16b83e 5586 /* Check if a moribund breakpoint explains the stop. */
1cf4d951
PA
5587 if (!target_supports_stopped_by_sw_breakpoint ()
5588 || !target_supports_stopped_by_hw_breakpoint ())
f431efe5 5589 {
1cf4d951 5590 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
f431efe5 5591 {
1cf4d951
PA
5592 if (breakpoint_location_address_match (loc, aspace, bp_addr)
5593 && need_moribund_for_location_type (loc))
5594 {
5595 bs = bpstat_alloc (loc, &bs_link);
5596 /* For hits of moribund locations, we should just proceed. */
5597 bs->stop = 0;
5598 bs->print = 0;
5599 bs->print_it = print_it_noop;
5600 }
f431efe5
PA
5601 }
5602 }
5603
edcc5120
TT
5604 /* A bit of special processing for shlib breakpoints. We need to
5605 process solib loading here, so that the lists of loaded and
5606 unloaded libraries are correct before we handle "catch load" and
5607 "catch unload". */
5608 for (bs = bs_head; bs != NULL; bs = bs->next)
5609 {
5d268276 5610 if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
edcc5120
TT
5611 {
5612 handle_solib_event ();
5613 break;
5614 }
5615 }
5616
f431efe5
PA
5617 /* Now go through the locations that caused the target to stop, and
5618 check whether we're interested in reporting this stop to higher
5619 layers, or whether we should resume the target transparently. */
5620
5621 removed_any = 0;
5622
5760d0ab 5623 for (bs = bs_head; bs != NULL; bs = bs->next)
f431efe5
PA
5624 {
5625 if (!bs->stop)
5626 continue;
5627
f431efe5 5628 b = bs->breakpoint_at;
348d480f
PA
5629 b->ops->check_status (bs);
5630 if (bs->stop)
28010a5d 5631 {
348d480f 5632 bpstat_check_breakpoint_conditions (bs, ptid);
f431efe5 5633
429374b8
JK
5634 if (bs->stop)
5635 {
5636 ++(b->hit_count);
8d3788bd 5637 observer_notify_breakpoint_modified (b);
c906108c 5638
4a64f543 5639 /* We will stop here. */
429374b8
JK
5640 if (b->disposition == disp_disable)
5641 {
816338b5 5642 --(b->enable_count);
1a853c52 5643 if (b->enable_count <= 0)
429374b8 5644 b->enable_state = bp_disabled;
f431efe5 5645 removed_any = 1;
429374b8
JK
5646 }
5647 if (b->silent)
5648 bs->print = 0;
5649 bs->commands = b->commands;
9add0f1b 5650 incref_counted_command_line (bs->commands);
abf85f46
JK
5651 if (command_line_is_silent (bs->commands
5652 ? bs->commands->commands : NULL))
5653 bs->print = 0;
9d6e6e84
HZ
5654
5655 b->ops->after_condition_true (bs);
429374b8
JK
5656 }
5657
348d480f 5658 }
a9b3a50f
PA
5659
5660 /* Print nothing for this entry if we don't stop or don't
5661 print. */
5662 if (!bs->stop || !bs->print)
5663 bs->print_it = print_it_noop;
429374b8 5664 }
876fa593 5665
d983da9c
DJ
5666 /* If we aren't stopping, the value of some hardware watchpoint may
5667 not have changed, but the intermediate memory locations we are
5668 watching may have. Don't bother if we're stopping; this will get
5669 done later. */
d832cb68 5670 need_remove_insert = 0;
5760d0ab
JK
5671 if (! bpstat_causes_stop (bs_head))
5672 for (bs = bs_head; bs != NULL; bs = bs->next)
d983da9c 5673 if (!bs->stop
f431efe5
PA
5674 && bs->breakpoint_at
5675 && is_hardware_watchpoint (bs->breakpoint_at))
d983da9c 5676 {
3a5c3e22
PA
5677 struct watchpoint *w = (struct watchpoint *) bs->breakpoint_at;
5678
5679 update_watchpoint (w, 0 /* don't reparse. */);
d832cb68 5680 need_remove_insert = 1;
d983da9c
DJ
5681 }
5682
d832cb68 5683 if (need_remove_insert)
44702360 5684 update_global_location_list (UGLL_MAY_INSERT);
f431efe5 5685 else if (removed_any)
44702360 5686 update_global_location_list (UGLL_DONT_INSERT);
d832cb68 5687
5760d0ab 5688 return bs_head;
c906108c 5689}
628fe4e4
JK
5690
5691static void
5692handle_jit_event (void)
5693{
5694 struct frame_info *frame;
5695 struct gdbarch *gdbarch;
5696
5697 /* Switch terminal for any messages produced by
5698 breakpoint_re_set. */
5699 target_terminal_ours_for_output ();
5700
5701 frame = get_current_frame ();
5702 gdbarch = get_frame_arch (frame);
5703
5704 jit_event_handler (gdbarch);
5705
5706 target_terminal_inferior ();
5707}
5708
5709/* Prepare WHAT final decision for infrun. */
5710
5711/* Decide what infrun needs to do with this bpstat. */
5712
c906108c 5713struct bpstat_what
0e30163f 5714bpstat_what (bpstat bs_head)
c906108c 5715{
c906108c 5716 struct bpstat_what retval;
628fe4e4 5717 int jit_event = 0;
0e30163f 5718 bpstat bs;
c906108c 5719
628fe4e4 5720 retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
aa7d318d 5721 retval.call_dummy = STOP_NONE;
186c406b 5722 retval.is_longjmp = 0;
628fe4e4 5723
0e30163f 5724 for (bs = bs_head; bs != NULL; bs = bs->next)
c906108c 5725 {
628fe4e4
JK
5726 /* Extract this BS's action. After processing each BS, we check
5727 if its action overrides all we've seem so far. */
5728 enum bpstat_what_main_action this_action = BPSTAT_WHAT_KEEP_CHECKING;
5729 enum bptype bptype;
5730
c906108c 5731 if (bs->breakpoint_at == NULL)
628fe4e4
JK
5732 {
5733 /* I suspect this can happen if it was a momentary
5734 breakpoint which has since been deleted. */
5735 bptype = bp_none;
5736 }
20874c92 5737 else
f431efe5 5738 bptype = bs->breakpoint_at->type;
628fe4e4
JK
5739
5740 switch (bptype)
c906108c
SS
5741 {
5742 case bp_none:
628fe4e4 5743 break;
c906108c
SS
5744 case bp_breakpoint:
5745 case bp_hardware_breakpoint:
7c16b83e 5746 case bp_single_step:
c906108c
SS
5747 case bp_until:
5748 case bp_finish:
a9b3a50f 5749 case bp_shlib_event:
c906108c
SS
5750 if (bs->stop)
5751 {
5752 if (bs->print)
628fe4e4 5753 this_action = BPSTAT_WHAT_STOP_NOISY;
c906108c 5754 else
628fe4e4 5755 this_action = BPSTAT_WHAT_STOP_SILENT;
c906108c
SS
5756 }
5757 else
628fe4e4 5758 this_action = BPSTAT_WHAT_SINGLE;
c906108c
SS
5759 break;
5760 case bp_watchpoint:
5761 case bp_hardware_watchpoint:
5762 case bp_read_watchpoint:
5763 case bp_access_watchpoint:
5764 if (bs->stop)
5765 {
5766 if (bs->print)
628fe4e4 5767 this_action = BPSTAT_WHAT_STOP_NOISY;
c906108c 5768 else
628fe4e4 5769 this_action = BPSTAT_WHAT_STOP_SILENT;
c906108c
SS
5770 }
5771 else
628fe4e4
JK
5772 {
5773 /* There was a watchpoint, but we're not stopping.
5774 This requires no further action. */
5775 }
c906108c
SS
5776 break;
5777 case bp_longjmp:
e2e4d78b 5778 case bp_longjmp_call_dummy:
186c406b 5779 case bp_exception:
0a39bb32
PA
5780 if (bs->stop)
5781 {
5782 this_action = BPSTAT_WHAT_SET_LONGJMP_RESUME;
5783 retval.is_longjmp = bptype != bp_exception;
5784 }
5785 else
5786 this_action = BPSTAT_WHAT_SINGLE;
c906108c
SS
5787 break;
5788 case bp_longjmp_resume:
186c406b 5789 case bp_exception_resume:
0a39bb32
PA
5790 if (bs->stop)
5791 {
5792 this_action = BPSTAT_WHAT_CLEAR_LONGJMP_RESUME;
5793 retval.is_longjmp = bptype == bp_longjmp_resume;
5794 }
5795 else
5796 this_action = BPSTAT_WHAT_SINGLE;
c906108c
SS
5797 break;
5798 case bp_step_resume:
5799 if (bs->stop)
628fe4e4
JK
5800 this_action = BPSTAT_WHAT_STEP_RESUME;
5801 else
c906108c 5802 {
628fe4e4
JK
5803 /* It is for the wrong frame. */
5804 this_action = BPSTAT_WHAT_SINGLE;
c906108c 5805 }
c906108c 5806 break;
2c03e5be
PA
5807 case bp_hp_step_resume:
5808 if (bs->stop)
5809 this_action = BPSTAT_WHAT_HP_STEP_RESUME;
5810 else
5811 {
5812 /* It is for the wrong frame. */
5813 this_action = BPSTAT_WHAT_SINGLE;
5814 }
5815 break;
c906108c 5816 case bp_watchpoint_scope:
c4093a6a 5817 case bp_thread_event:
1900040c 5818 case bp_overlay_event:
0fd8e87f 5819 case bp_longjmp_master:
aa7d318d 5820 case bp_std_terminate_master:
186c406b 5821 case bp_exception_master:
628fe4e4 5822 this_action = BPSTAT_WHAT_SINGLE;
c4093a6a 5823 break;
ce78b96d 5824 case bp_catchpoint:
c5aa993b
JM
5825 if (bs->stop)
5826 {
5827 if (bs->print)
628fe4e4 5828 this_action = BPSTAT_WHAT_STOP_NOISY;
c5aa993b 5829 else
628fe4e4 5830 this_action = BPSTAT_WHAT_STOP_SILENT;
c5aa993b
JM
5831 }
5832 else
628fe4e4
JK
5833 {
5834 /* There was a catchpoint, but we're not stopping.
5835 This requires no further action. */
5836 }
5837 break;
628fe4e4
JK
5838 case bp_jit_event:
5839 jit_event = 1;
5840 this_action = BPSTAT_WHAT_SINGLE;
c5aa993b 5841 break;
c906108c 5842 case bp_call_dummy:
53a5351d
JM
5843 /* Make sure the action is stop (silent or noisy),
5844 so infrun.c pops the dummy frame. */
aa7d318d 5845 retval.call_dummy = STOP_STACK_DUMMY;
628fe4e4 5846 this_action = BPSTAT_WHAT_STOP_SILENT;
aa7d318d
TT
5847 break;
5848 case bp_std_terminate:
5849 /* Make sure the action is stop (silent or noisy),
5850 so infrun.c pops the dummy frame. */
aa7d318d 5851 retval.call_dummy = STOP_STD_TERMINATE;
628fe4e4 5852 this_action = BPSTAT_WHAT_STOP_SILENT;
c906108c 5853 break;
1042e4c0 5854 case bp_tracepoint:
7a697b8d 5855 case bp_fast_tracepoint:
0fb4aa4b 5856 case bp_static_tracepoint:
1042e4c0
SS
5857 /* Tracepoint hits should not be reported back to GDB, and
5858 if one got through somehow, it should have been filtered
5859 out already. */
5860 internal_error (__FILE__, __LINE__,
7a697b8d 5861 _("bpstat_what: tracepoint encountered"));
0e30163f
JK
5862 break;
5863 case bp_gnu_ifunc_resolver:
5864 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5865 this_action = BPSTAT_WHAT_SINGLE;
5866 break;
5867 case bp_gnu_ifunc_resolver_return:
5868 /* The breakpoint will be removed, execution will restart from the
5869 PC of the former breakpoint. */
5870 this_action = BPSTAT_WHAT_KEEP_CHECKING;
5871 break;
e7e0cddf
SS
5872
5873 case bp_dprintf:
a11cfd87
HZ
5874 if (bs->stop)
5875 this_action = BPSTAT_WHAT_STOP_SILENT;
5876 else
5877 this_action = BPSTAT_WHAT_SINGLE;
e7e0cddf
SS
5878 break;
5879
628fe4e4
JK
5880 default:
5881 internal_error (__FILE__, __LINE__,
5882 _("bpstat_what: unhandled bptype %d"), (int) bptype);
c906108c 5883 }
628fe4e4
JK
5884
5885 retval.main_action = max (retval.main_action, this_action);
c906108c 5886 }
628fe4e4 5887
0e30163f
JK
5888 /* These operations may affect the bs->breakpoint_at state so they are
5889 delayed after MAIN_ACTION is decided above. */
5890
628fe4e4
JK
5891 if (jit_event)
5892 {
5893 if (debug_infrun)
5894 fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_jit_event\n");
5895
5896 handle_jit_event ();
5897 }
5898
0e30163f
JK
5899 for (bs = bs_head; bs != NULL; bs = bs->next)
5900 {
5901 struct breakpoint *b = bs->breakpoint_at;
5902
5903 if (b == NULL)
5904 continue;
5905 switch (b->type)
5906 {
5907 case bp_gnu_ifunc_resolver:
5908 gnu_ifunc_resolver_stop (b);
5909 break;
5910 case bp_gnu_ifunc_resolver_return:
5911 gnu_ifunc_resolver_return_stop (b);
5912 break;
5913 }
5914 }
5915
c906108c
SS
5916 return retval;
5917}
5918
5919/* Nonzero if we should step constantly (e.g. watchpoints on machines
5920 without hardware support). This isn't related to a specific bpstat,
5921 just to things like whether watchpoints are set. */
5922
c5aa993b 5923int
fba45db2 5924bpstat_should_step (void)
c906108c
SS
5925{
5926 struct breakpoint *b;
cc59ec59 5927
c906108c 5928 ALL_BREAKPOINTS (b)
717a8278 5929 if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
3172dc30 5930 return 1;
c906108c
SS
5931 return 0;
5932}
5933
67822962
PA
5934int
5935bpstat_causes_stop (bpstat bs)
5936{
5937 for (; bs != NULL; bs = bs->next)
5938 if (bs->stop)
5939 return 1;
5940
5941 return 0;
5942}
5943
c906108c 5944\f
c5aa993b 5945
170b53b2
UW
5946/* Compute a string of spaces suitable to indent the next line
5947 so it starts at the position corresponding to the table column
5948 named COL_NAME in the currently active table of UIOUT. */
5949
5950static char *
5951wrap_indent_at_field (struct ui_out *uiout, const char *col_name)
5952{
5953 static char wrap_indent[80];
5954 int i, total_width, width, align;
5955 char *text;
5956
5957 total_width = 0;
5958 for (i = 1; ui_out_query_field (uiout, i, &width, &align, &text); i++)
5959 {
5960 if (strcmp (text, col_name) == 0)
5961 {
5962 gdb_assert (total_width < sizeof wrap_indent);
5963 memset (wrap_indent, ' ', total_width);
5964 wrap_indent[total_width] = 0;
5965
5966 return wrap_indent;
5967 }
5968
5969 total_width += width + 1;
5970 }
5971
5972 return NULL;
5973}
5974
b775012e
LM
5975/* Determine if the locations of this breakpoint will have their conditions
5976 evaluated by the target, host or a mix of both. Returns the following:
5977
5978 "host": Host evals condition.
5979 "host or target": Host or Target evals condition.
5980 "target": Target evals condition.
5981*/
5982
5983static const char *
5984bp_condition_evaluator (struct breakpoint *b)
5985{
5986 struct bp_location *bl;
5987 char host_evals = 0;
5988 char target_evals = 0;
5989
5990 if (!b)
5991 return NULL;
5992
5993 if (!is_breakpoint (b))
5994 return NULL;
5995
5996 if (gdb_evaluates_breakpoint_condition_p ()
5997 || !target_supports_evaluation_of_breakpoint_conditions ())
5998 return condition_evaluation_host;
5999
6000 for (bl = b->loc; bl; bl = bl->next)
6001 {
6002 if (bl->cond_bytecode)
6003 target_evals++;
6004 else
6005 host_evals++;
6006 }
6007
6008 if (host_evals && target_evals)
6009 return condition_evaluation_both;
6010 else if (target_evals)
6011 return condition_evaluation_target;
6012 else
6013 return condition_evaluation_host;
6014}
6015
6016/* Determine the breakpoint location's condition evaluator. This is
6017 similar to bp_condition_evaluator, but for locations. */
6018
6019static const char *
6020bp_location_condition_evaluator (struct bp_location *bl)
6021{
6022 if (bl && !is_breakpoint (bl->owner))
6023 return NULL;
6024
6025 if (gdb_evaluates_breakpoint_condition_p ()
6026 || !target_supports_evaluation_of_breakpoint_conditions ())
6027 return condition_evaluation_host;
6028
6029 if (bl && bl->cond_bytecode)
6030 return condition_evaluation_target;
6031 else
6032 return condition_evaluation_host;
6033}
6034
859825b8
JK
6035/* Print the LOC location out of the list of B->LOC locations. */
6036
170b53b2
UW
6037static void
6038print_breakpoint_location (struct breakpoint *b,
6039 struct bp_location *loc)
0d381245 6040{
79a45e25 6041 struct ui_out *uiout = current_uiout;
6c95b8df
PA
6042 struct cleanup *old_chain = save_current_program_space ();
6043
859825b8
JK
6044 if (loc != NULL && loc->shlib_disabled)
6045 loc = NULL;
6046
6c95b8df
PA
6047 if (loc != NULL)
6048 set_current_program_space (loc->pspace);
6049
56435ebe 6050 if (b->display_canonical)
f00aae0f
KS
6051 ui_out_field_string (uiout, "what",
6052 event_location_to_string (b->location));
2f202fde 6053 else if (loc && loc->symtab)
0d381245
VP
6054 {
6055 struct symbol *sym
6056 = find_pc_sect_function (loc->address, loc->section);
6057 if (sym)
6058 {
6059 ui_out_text (uiout, "in ");
6060 ui_out_field_string (uiout, "func",
6061 SYMBOL_PRINT_NAME (sym));
170b53b2
UW
6062 ui_out_text (uiout, " ");
6063 ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
6064 ui_out_text (uiout, "at ");
0d381245 6065 }
05cba821
JK
6066 ui_out_field_string (uiout, "file",
6067 symtab_to_filename_for_display (loc->symtab));
0d381245 6068 ui_out_text (uiout, ":");
05cba821 6069
0d381245 6070 if (ui_out_is_mi_like_p (uiout))
2f202fde
JK
6071 ui_out_field_string (uiout, "fullname",
6072 symtab_to_fullname (loc->symtab));
0d381245 6073
f8eba3c6 6074 ui_out_field_int (uiout, "line", loc->line_number);
0d381245 6075 }
859825b8 6076 else if (loc)
0d381245 6077 {
f99d8bf4
PA
6078 struct ui_file *stb = mem_fileopen ();
6079 struct cleanup *stb_chain = make_cleanup_ui_file_delete (stb);
170b53b2 6080
f99d8bf4 6081 print_address_symbolic (loc->gdbarch, loc->address, stb,
22e722e1 6082 demangle, "");
0d381245 6083 ui_out_field_stream (uiout, "at", stb);
170b53b2
UW
6084
6085 do_cleanups (stb_chain);
0d381245 6086 }
859825b8 6087 else
f00aae0f
KS
6088 {
6089 ui_out_field_string (uiout, "pending",
6090 event_location_to_string (b->location));
6091 /* If extra_string is available, it could be holding a condition
6092 or dprintf arguments. In either case, make sure it is printed,
6093 too, but only for non-MI streams. */
6094 if (!ui_out_is_mi_like_p (uiout) && b->extra_string != NULL)
6095 {
6096 if (b->type == bp_dprintf)
6097 ui_out_text (uiout, ",");
6098 else
6099 ui_out_text (uiout, " ");
6100 ui_out_text (uiout, b->extra_string);
6101 }
6102 }
6c95b8df 6103
b775012e
LM
6104 if (loc && is_breakpoint (b)
6105 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6106 && bp_condition_evaluator (b) == condition_evaluation_both)
6107 {
6108 ui_out_text (uiout, " (");
6109 ui_out_field_string (uiout, "evaluated-by",
6110 bp_location_condition_evaluator (loc));
6111 ui_out_text (uiout, ")");
6112 }
6113
6c95b8df 6114 do_cleanups (old_chain);
0d381245
VP
6115}
6116
269b11a2
PA
6117static const char *
6118bptype_string (enum bptype type)
c906108c 6119{
c4093a6a
JM
6120 struct ep_type_description
6121 {
6122 enum bptype type;
6123 char *description;
6124 };
6125 static struct ep_type_description bptypes[] =
c906108c 6126 {
c5aa993b
JM
6127 {bp_none, "?deleted?"},
6128 {bp_breakpoint, "breakpoint"},
c906108c 6129 {bp_hardware_breakpoint, "hw breakpoint"},
7c16b83e 6130 {bp_single_step, "sw single-step"},
c5aa993b
JM
6131 {bp_until, "until"},
6132 {bp_finish, "finish"},
6133 {bp_watchpoint, "watchpoint"},
c906108c 6134 {bp_hardware_watchpoint, "hw watchpoint"},
c5aa993b
JM
6135 {bp_read_watchpoint, "read watchpoint"},
6136 {bp_access_watchpoint, "acc watchpoint"},
6137 {bp_longjmp, "longjmp"},
6138 {bp_longjmp_resume, "longjmp resume"},
e2e4d78b 6139 {bp_longjmp_call_dummy, "longjmp for call dummy"},
186c406b
TT
6140 {bp_exception, "exception"},
6141 {bp_exception_resume, "exception resume"},
c5aa993b 6142 {bp_step_resume, "step resume"},
2c03e5be 6143 {bp_hp_step_resume, "high-priority step resume"},
c5aa993b
JM
6144 {bp_watchpoint_scope, "watchpoint scope"},
6145 {bp_call_dummy, "call dummy"},
aa7d318d 6146 {bp_std_terminate, "std::terminate"},
c5aa993b 6147 {bp_shlib_event, "shlib events"},
c4093a6a 6148 {bp_thread_event, "thread events"},
1900040c 6149 {bp_overlay_event, "overlay events"},
0fd8e87f 6150 {bp_longjmp_master, "longjmp master"},
aa7d318d 6151 {bp_std_terminate_master, "std::terminate master"},
186c406b 6152 {bp_exception_master, "exception master"},
ce78b96d 6153 {bp_catchpoint, "catchpoint"},
1042e4c0 6154 {bp_tracepoint, "tracepoint"},
7a697b8d 6155 {bp_fast_tracepoint, "fast tracepoint"},
0fb4aa4b 6156 {bp_static_tracepoint, "static tracepoint"},
e7e0cddf 6157 {bp_dprintf, "dprintf"},
4efc6507 6158 {bp_jit_event, "jit events"},
0e30163f
JK
6159 {bp_gnu_ifunc_resolver, "STT_GNU_IFUNC resolver"},
6160 {bp_gnu_ifunc_resolver_return, "STT_GNU_IFUNC resolver return"},
c5aa993b 6161 };
269b11a2
PA
6162
6163 if (((int) type >= (sizeof (bptypes) / sizeof (bptypes[0])))
6164 || ((int) type != bptypes[(int) type].type))
6165 internal_error (__FILE__, __LINE__,
6166 _("bptypes table does not describe type #%d."),
6167 (int) type);
6168
6169 return bptypes[(int) type].description;
6170}
6171
998580f1
MK
6172/* For MI, output a field named 'thread-groups' with a list as the value.
6173 For CLI, prefix the list with the string 'inf'. */
6174
6175static void
6176output_thread_groups (struct ui_out *uiout,
6177 const char *field_name,
6178 VEC(int) *inf_num,
6179 int mi_only)
6180{
752eb8b4 6181 struct cleanup *back_to;
998580f1
MK
6182 int is_mi = ui_out_is_mi_like_p (uiout);
6183 int inf;
6184 int i;
6185
6186 /* For backward compatibility, don't display inferiors in CLI unless
6187 there are several. Always display them for MI. */
6188 if (!is_mi && mi_only)
6189 return;
6190
752eb8b4
TT
6191 back_to = make_cleanup_ui_out_list_begin_end (uiout, field_name);
6192
998580f1
MK
6193 for (i = 0; VEC_iterate (int, inf_num, i, inf); ++i)
6194 {
6195 if (is_mi)
6196 {
6197 char mi_group[10];
6198
6199 xsnprintf (mi_group, sizeof (mi_group), "i%d", inf);
6200 ui_out_field_string (uiout, NULL, mi_group);
6201 }
6202 else
6203 {
6204 if (i == 0)
6205 ui_out_text (uiout, " inf ");
6206 else
6207 ui_out_text (uiout, ", ");
6208
6209 ui_out_text (uiout, plongest (inf));
6210 }
6211 }
6212
6213 do_cleanups (back_to);
6214}
6215
269b11a2
PA
6216/* Print B to gdb_stdout. */
6217
6218static void
6219print_one_breakpoint_location (struct breakpoint *b,
6220 struct bp_location *loc,
6221 int loc_number,
6222 struct bp_location **last_loc,
269b11a2
PA
6223 int allflag)
6224{
6225 struct command_line *l;
c2c6d25f 6226 static char bpenables[] = "nynny";
c906108c 6227
79a45e25 6228 struct ui_out *uiout = current_uiout;
0d381245
VP
6229 int header_of_multiple = 0;
6230 int part_of_multiple = (loc != NULL);
79a45b7d
TT
6231 struct value_print_options opts;
6232
6233 get_user_print_options (&opts);
0d381245
VP
6234
6235 gdb_assert (!loc || loc_number != 0);
4a64f543
MS
6236 /* See comment in print_one_breakpoint concerning treatment of
6237 breakpoints with single disabled location. */
0d381245
VP
6238 if (loc == NULL
6239 && (b->loc != NULL
6240 && (b->loc->next != NULL || !b->loc->enabled)))
6241 header_of_multiple = 1;
6242 if (loc == NULL)
6243 loc = b->loc;
6244
c4093a6a
JM
6245 annotate_record ();
6246
6247 /* 1 */
6248 annotate_field (0);
0d381245
VP
6249 if (part_of_multiple)
6250 {
6251 char *formatted;
0c6773c1 6252 formatted = xstrprintf ("%d.%d", b->number, loc_number);
0d381245
VP
6253 ui_out_field_string (uiout, "number", formatted);
6254 xfree (formatted);
6255 }
6256 else
6257 {
6258 ui_out_field_int (uiout, "number", b->number);
6259 }
c4093a6a
JM
6260
6261 /* 2 */
6262 annotate_field (1);
0d381245
VP
6263 if (part_of_multiple)
6264 ui_out_field_skip (uiout, "type");
269b11a2
PA
6265 else
6266 ui_out_field_string (uiout, "type", bptype_string (b->type));
c4093a6a
JM
6267
6268 /* 3 */
6269 annotate_field (2);
0d381245
VP
6270 if (part_of_multiple)
6271 ui_out_field_skip (uiout, "disp");
6272 else
2cec12e5 6273 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
0d381245 6274
c4093a6a
JM
6275
6276 /* 4 */
6277 annotate_field (3);
0d381245 6278 if (part_of_multiple)
54e52265 6279 ui_out_field_string (uiout, "enabled", loc->enabled ? "y" : "n");
0d381245 6280 else
4a64f543
MS
6281 ui_out_field_fmt (uiout, "enabled", "%c",
6282 bpenables[(int) b->enable_state]);
54e52265 6283 ui_out_spaces (uiout, 2);
0d381245 6284
c4093a6a
JM
6285
6286 /* 5 and 6 */
3086aeae 6287 if (b->ops != NULL && b->ops->print_one != NULL)
0d381245 6288 {
4a64f543
MS
6289 /* Although the print_one can possibly print all locations,
6290 calling it here is not likely to get any nice result. So,
6291 make sure there's just one location. */
0d381245 6292 gdb_assert (b->loc == NULL || b->loc->next == NULL);
a6d9a66e 6293 b->ops->print_one (b, last_loc);
0d381245 6294 }
3086aeae
DJ
6295 else
6296 switch (b->type)
6297 {
6298 case bp_none:
6299 internal_error (__FILE__, __LINE__,
e2e0b3e5 6300 _("print_one_breakpoint: bp_none encountered\n"));
3086aeae 6301 break;
c906108c 6302
3086aeae
DJ
6303 case bp_watchpoint:
6304 case bp_hardware_watchpoint:
6305 case bp_read_watchpoint:
6306 case bp_access_watchpoint:
3a5c3e22
PA
6307 {
6308 struct watchpoint *w = (struct watchpoint *) b;
6309
6310 /* Field 4, the address, is omitted (which makes the columns
6311 not line up too nicely with the headers, but the effect
6312 is relatively readable). */
6313 if (opts.addressprint)
6314 ui_out_field_skip (uiout, "addr");
6315 annotate_field (5);
6316 ui_out_field_string (uiout, "what", w->exp_string);
6317 }
3086aeae
DJ
6318 break;
6319
3086aeae
DJ
6320 case bp_breakpoint:
6321 case bp_hardware_breakpoint:
7c16b83e 6322 case bp_single_step:
3086aeae
DJ
6323 case bp_until:
6324 case bp_finish:
6325 case bp_longjmp:
6326 case bp_longjmp_resume:
e2e4d78b 6327 case bp_longjmp_call_dummy:
186c406b
TT
6328 case bp_exception:
6329 case bp_exception_resume:
3086aeae 6330 case bp_step_resume:
2c03e5be 6331 case bp_hp_step_resume:
3086aeae
DJ
6332 case bp_watchpoint_scope:
6333 case bp_call_dummy:
aa7d318d 6334 case bp_std_terminate:
3086aeae
DJ
6335 case bp_shlib_event:
6336 case bp_thread_event:
6337 case bp_overlay_event:
0fd8e87f 6338 case bp_longjmp_master:
aa7d318d 6339 case bp_std_terminate_master:
186c406b 6340 case bp_exception_master:
1042e4c0 6341 case bp_tracepoint:
7a697b8d 6342 case bp_fast_tracepoint:
0fb4aa4b 6343 case bp_static_tracepoint:
e7e0cddf 6344 case bp_dprintf:
4efc6507 6345 case bp_jit_event:
0e30163f
JK
6346 case bp_gnu_ifunc_resolver:
6347 case bp_gnu_ifunc_resolver_return:
79a45b7d 6348 if (opts.addressprint)
3086aeae
DJ
6349 {
6350 annotate_field (4);
54e52265 6351 if (header_of_multiple)
0d381245 6352 ui_out_field_string (uiout, "addr", "<MULTIPLE>");
e9bbd7c5 6353 else if (b->loc == NULL || loc->shlib_disabled)
54e52265 6354 ui_out_field_string (uiout, "addr", "<PENDING>");
0101ce28 6355 else
5af949e3
UW
6356 ui_out_field_core_addr (uiout, "addr",
6357 loc->gdbarch, loc->address);
3086aeae
DJ
6358 }
6359 annotate_field (5);
0d381245 6360 if (!header_of_multiple)
170b53b2 6361 print_breakpoint_location (b, loc);
0d381245 6362 if (b->loc)
a6d9a66e 6363 *last_loc = b->loc;
3086aeae
DJ
6364 break;
6365 }
c906108c 6366
6c95b8df 6367
998580f1 6368 if (loc != NULL && !header_of_multiple)
6c95b8df
PA
6369 {
6370 struct inferior *inf;
998580f1
MK
6371 VEC(int) *inf_num = NULL;
6372 int mi_only = 1;
6c95b8df 6373
998580f1 6374 ALL_INFERIORS (inf)
6c95b8df
PA
6375 {
6376 if (inf->pspace == loc->pspace)
998580f1 6377 VEC_safe_push (int, inf_num, inf->num);
6c95b8df 6378 }
998580f1
MK
6379
6380 /* For backward compatibility, don't display inferiors in CLI unless
6381 there are several. Always display for MI. */
6382 if (allflag
6383 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6384 && (number_of_program_spaces () > 1
6385 || number_of_inferiors () > 1)
6386 /* LOC is for existing B, it cannot be in
6387 moribund_locations and thus having NULL OWNER. */
6388 && loc->owner->type != bp_catchpoint))
6389 mi_only = 0;
6390 output_thread_groups (uiout, "thread-groups", inf_num, mi_only);
6391 VEC_free (int, inf_num);
6c95b8df
PA
6392 }
6393
4a306c9a 6394 if (!part_of_multiple)
c4093a6a 6395 {
4a306c9a
JB
6396 if (b->thread != -1)
6397 {
6398 /* FIXME: This seems to be redundant and lost here; see the
4a64f543 6399 "stop only in" line a little further down. */
4a306c9a
JB
6400 ui_out_text (uiout, " thread ");
6401 ui_out_field_int (uiout, "thread", b->thread);
6402 }
6403 else if (b->task != 0)
6404 {
6405 ui_out_text (uiout, " task ");
6406 ui_out_field_int (uiout, "task", b->task);
6407 }
c4093a6a 6408 }
f1310107 6409
8b93c638 6410 ui_out_text (uiout, "\n");
f1310107 6411
348d480f 6412 if (!part_of_multiple)
f1310107
TJB
6413 b->ops->print_one_detail (b, uiout);
6414
0d381245 6415 if (part_of_multiple && frame_id_p (b->frame_id))
c4093a6a
JM
6416 {
6417 annotate_field (6);
8b93c638 6418 ui_out_text (uiout, "\tstop only in stack frame at ");
e5dd4106 6419 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
818dd999 6420 the frame ID. */
5af949e3
UW
6421 ui_out_field_core_addr (uiout, "frame",
6422 b->gdbarch, b->frame_id.stack_addr);
8b93c638 6423 ui_out_text (uiout, "\n");
c4093a6a
JM
6424 }
6425
28010a5d 6426 if (!part_of_multiple && b->cond_string)
c4093a6a
JM
6427 {
6428 annotate_field (7);
d77f58be 6429 if (is_tracepoint (b))
1042e4c0
SS
6430 ui_out_text (uiout, "\ttrace only if ");
6431 else
6432 ui_out_text (uiout, "\tstop only if ");
0101ce28 6433 ui_out_field_string (uiout, "cond", b->cond_string);
b775012e
LM
6434
6435 /* Print whether the target is doing the breakpoint's condition
6436 evaluation. If GDB is doing the evaluation, don't print anything. */
6437 if (is_breakpoint (b)
6438 && breakpoint_condition_evaluation_mode ()
6439 == condition_evaluation_target)
6440 {
6441 ui_out_text (uiout, " (");
6442 ui_out_field_string (uiout, "evaluated-by",
6443 bp_condition_evaluator (b));
6444 ui_out_text (uiout, " evals)");
6445 }
0101ce28
JJ
6446 ui_out_text (uiout, "\n");
6447 }
6448
0d381245 6449 if (!part_of_multiple && b->thread != -1)
c4093a6a 6450 {
4a64f543 6451 /* FIXME should make an annotation for this. */
8b93c638
JM
6452 ui_out_text (uiout, "\tstop only in thread ");
6453 ui_out_field_int (uiout, "thread", b->thread);
6454 ui_out_text (uiout, "\n");
c4093a6a
JM
6455 }
6456
556ec64d
YQ
6457 if (!part_of_multiple)
6458 {
6459 if (b->hit_count)
31f56a27
YQ
6460 {
6461 /* FIXME should make an annotation for this. */
6462 if (is_catchpoint (b))
6463 ui_out_text (uiout, "\tcatchpoint");
6464 else if (is_tracepoint (b))
6465 ui_out_text (uiout, "\ttracepoint");
6466 else
6467 ui_out_text (uiout, "\tbreakpoint");
6468 ui_out_text (uiout, " already hit ");
6469 ui_out_field_int (uiout, "times", b->hit_count);
6470 if (b->hit_count == 1)
6471 ui_out_text (uiout, " time\n");
6472 else
6473 ui_out_text (uiout, " times\n");
6474 }
556ec64d
YQ
6475 else
6476 {
31f56a27
YQ
6477 /* Output the count also if it is zero, but only if this is mi. */
6478 if (ui_out_is_mi_like_p (uiout))
6479 ui_out_field_int (uiout, "times", b->hit_count);
556ec64d
YQ
6480 }
6481 }
8b93c638 6482
0d381245 6483 if (!part_of_multiple && b->ignore_count)
c4093a6a
JM
6484 {
6485 annotate_field (8);
8b93c638
JM
6486 ui_out_text (uiout, "\tignore next ");
6487 ui_out_field_int (uiout, "ignore", b->ignore_count);
6488 ui_out_text (uiout, " hits\n");
c4093a6a 6489 }
059fb39f 6490
816338b5
SS
6491 /* Note that an enable count of 1 corresponds to "enable once"
6492 behavior, which is reported by the combination of enablement and
6493 disposition, so we don't need to mention it here. */
6494 if (!part_of_multiple && b->enable_count > 1)
6495 {
6496 annotate_field (8);
6497 ui_out_text (uiout, "\tdisable after ");
6498 /* Tweak the wording to clarify that ignore and enable counts
6499 are distinct, and have additive effect. */
6500 if (b->ignore_count)
6501 ui_out_text (uiout, "additional ");
6502 else
6503 ui_out_text (uiout, "next ");
6504 ui_out_field_int (uiout, "enable", b->enable_count);
6505 ui_out_text (uiout, " hits\n");
6506 }
6507
f196051f
SS
6508 if (!part_of_multiple && is_tracepoint (b))
6509 {
6510 struct tracepoint *tp = (struct tracepoint *) b;
6511
6512 if (tp->traceframe_usage)
6513 {
6514 ui_out_text (uiout, "\ttrace buffer usage ");
6515 ui_out_field_int (uiout, "traceframe-usage", tp->traceframe_usage);
6516 ui_out_text (uiout, " bytes\n");
6517 }
6518 }
d3ce09f5 6519
9add0f1b 6520 l = b->commands ? b->commands->commands : NULL;
059fb39f 6521 if (!part_of_multiple && l)
c4093a6a 6522 {
3b31d625
EZ
6523 struct cleanup *script_chain;
6524
c4093a6a 6525 annotate_field (9);
3b31d625 6526 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
8b93c638 6527 print_command_lines (uiout, l, 4);
3b31d625 6528 do_cleanups (script_chain);
c4093a6a 6529 }
d24317b4 6530
d9b3f62e 6531 if (is_tracepoint (b))
1042e4c0 6532 {
d9b3f62e
PA
6533 struct tracepoint *t = (struct tracepoint *) b;
6534
6535 if (!part_of_multiple && t->pass_count)
6536 {
6537 annotate_field (10);
6538 ui_out_text (uiout, "\tpass count ");
6539 ui_out_field_int (uiout, "pass", t->pass_count);
6540 ui_out_text (uiout, " \n");
6541 }
f2a8bc8a
YQ
6542
6543 /* Don't display it when tracepoint or tracepoint location is
6544 pending. */
6545 if (!header_of_multiple && loc != NULL && !loc->shlib_disabled)
6546 {
6547 annotate_field (11);
6548
6549 if (ui_out_is_mi_like_p (uiout))
6550 ui_out_field_string (uiout, "installed",
6551 loc->inserted ? "y" : "n");
6552 else
6553 {
6554 if (loc->inserted)
6555 ui_out_text (uiout, "\t");
6556 else
6557 ui_out_text (uiout, "\tnot ");
6558 ui_out_text (uiout, "installed on target\n");
6559 }
6560 }
1042e4c0
SS
6561 }
6562
d24317b4
VP
6563 if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
6564 {
3a5c3e22
PA
6565 if (is_watchpoint (b))
6566 {
6567 struct watchpoint *w = (struct watchpoint *) b;
6568
6569 ui_out_field_string (uiout, "original-location", w->exp_string);
6570 }
f00aae0f
KS
6571 else if (b->location != NULL
6572 && event_location_to_string (b->location) != NULL)
6573 ui_out_field_string (uiout, "original-location",
6574 event_location_to_string (b->location));
d24317b4 6575 }
c4093a6a 6576}
c5aa993b 6577
0d381245
VP
6578static void
6579print_one_breakpoint (struct breakpoint *b,
4a64f543 6580 struct bp_location **last_loc,
6c95b8df 6581 int allflag)
0d381245 6582{
8d3788bd 6583 struct cleanup *bkpt_chain;
79a45e25 6584 struct ui_out *uiout = current_uiout;
8d3788bd
VP
6585
6586 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
6587
12c5a436 6588 print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
8d3788bd 6589 do_cleanups (bkpt_chain);
0d381245
VP
6590
6591 /* If this breakpoint has custom print function,
6592 it's already printed. Otherwise, print individual
6593 locations, if any. */
6594 if (b->ops == NULL || b->ops->print_one == NULL)
6595 {
4a64f543
MS
6596 /* If breakpoint has a single location that is disabled, we
6597 print it as if it had several locations, since otherwise it's
6598 hard to represent "breakpoint enabled, location disabled"
6599 situation.
6600
6601 Note that while hardware watchpoints have several locations
a3be7890 6602 internally, that's not a property exposed to user. */
0d381245 6603 if (b->loc
a5606eee 6604 && !is_hardware_watchpoint (b)
8d3788bd 6605 && (b->loc->next || !b->loc->enabled))
0d381245
VP
6606 {
6607 struct bp_location *loc;
6608 int n = 1;
8d3788bd 6609
0d381245 6610 for (loc = b->loc; loc; loc = loc->next, ++n)
8d3788bd
VP
6611 {
6612 struct cleanup *inner2 =
6613 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
6614 print_one_breakpoint_location (b, loc, n, last_loc, allflag);
6615 do_cleanups (inner2);
6616 }
0d381245
VP
6617 }
6618 }
6619}
6620
a6d9a66e
UW
6621static int
6622breakpoint_address_bits (struct breakpoint *b)
6623{
6624 int print_address_bits = 0;
6625 struct bp_location *loc;
6626
6627 for (loc = b->loc; loc; loc = loc->next)
6628 {
c7437ca6
PA
6629 int addr_bit;
6630
6631 /* Software watchpoints that aren't watching memory don't have
6632 an address to print. */
6633 if (b->type == bp_watchpoint && loc->watchpoint_type == -1)
6634 continue;
6635
6636 addr_bit = gdbarch_addr_bit (loc->gdbarch);
a6d9a66e
UW
6637 if (addr_bit > print_address_bits)
6638 print_address_bits = addr_bit;
6639 }
6640
6641 return print_address_bits;
6642}
0d381245 6643
c4093a6a
JM
6644struct captured_breakpoint_query_args
6645 {
6646 int bnum;
6647 };
c5aa993b 6648
c4093a6a 6649static int
2b65245e 6650do_captured_breakpoint_query (struct ui_out *uiout, void *data)
c4093a6a
JM
6651{
6652 struct captured_breakpoint_query_args *args = data;
52f0bd74 6653 struct breakpoint *b;
a6d9a66e 6654 struct bp_location *dummy_loc = NULL;
cc59ec59 6655
c4093a6a
JM
6656 ALL_BREAKPOINTS (b)
6657 {
6658 if (args->bnum == b->number)
c5aa993b 6659 {
12c5a436 6660 print_one_breakpoint (b, &dummy_loc, 0);
c4093a6a 6661 return GDB_RC_OK;
c5aa993b 6662 }
c4093a6a
JM
6663 }
6664 return GDB_RC_NONE;
6665}
c5aa993b 6666
c4093a6a 6667enum gdb_rc
4a64f543
MS
6668gdb_breakpoint_query (struct ui_out *uiout, int bnum,
6669 char **error_message)
c4093a6a
JM
6670{
6671 struct captured_breakpoint_query_args args;
cc59ec59 6672
c4093a6a
JM
6673 args.bnum = bnum;
6674 /* For the moment we don't trust print_one_breakpoint() to not throw
4a64f543 6675 an error. */
b0b13bb4
DJ
6676 if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
6677 error_message, RETURN_MASK_ALL) < 0)
6678 return GDB_RC_FAIL;
6679 else
6680 return GDB_RC_OK;
c4093a6a 6681}
c5aa993b 6682
09d682a4
TT
6683/* Return true if this breakpoint was set by the user, false if it is
6684 internal or momentary. */
6685
6686int
6687user_breakpoint_p (struct breakpoint *b)
6688{
46c6471b 6689 return b->number > 0;
09d682a4
TT
6690}
6691
7f3b0473 6692/* Print information on user settable breakpoint (watchpoint, etc)
d77f58be
SS
6693 number BNUM. If BNUM is -1 print all user-settable breakpoints.
6694 If ALLFLAG is non-zero, include non-user-settable breakpoints. If
6695 FILTER is non-NULL, call it on each breakpoint and only include the
6696 ones for which it returns non-zero. Return the total number of
6697 breakpoints listed. */
c906108c 6698
d77f58be 6699static int
e5a67952 6700breakpoint_1 (char *args, int allflag,
4a64f543 6701 int (*filter) (const struct breakpoint *))
c4093a6a 6702{
52f0bd74 6703 struct breakpoint *b;
a6d9a66e 6704 struct bp_location *last_loc = NULL;
7f3b0473 6705 int nr_printable_breakpoints;
3b31d625 6706 struct cleanup *bkpttbl_chain;
79a45b7d 6707 struct value_print_options opts;
a6d9a66e 6708 int print_address_bits = 0;
269b11a2 6709 int print_type_col_width = 14;
79a45e25 6710 struct ui_out *uiout = current_uiout;
269b11a2 6711
79a45b7d
TT
6712 get_user_print_options (&opts);
6713
4a64f543
MS
6714 /* Compute the number of rows in the table, as well as the size
6715 required for address fields. */
7f3b0473
AC
6716 nr_printable_breakpoints = 0;
6717 ALL_BREAKPOINTS (b)
e5a67952
MS
6718 {
6719 /* If we have a filter, only list the breakpoints it accepts. */
6720 if (filter && !filter (b))
6721 continue;
6722
6723 /* If we have an "args" string, it is a list of breakpoints to
6724 accept. Skip the others. */
6725 if (args != NULL && *args != '\0')
6726 {
6727 if (allflag && parse_and_eval_long (args) != b->number)
6728 continue;
6729 if (!allflag && !number_is_in_list (args, b->number))
6730 continue;
6731 }
269b11a2 6732
e5a67952
MS
6733 if (allflag || user_breakpoint_p (b))
6734 {
6735 int addr_bit, type_len;
a6d9a66e 6736
e5a67952
MS
6737 addr_bit = breakpoint_address_bits (b);
6738 if (addr_bit > print_address_bits)
6739 print_address_bits = addr_bit;
269b11a2 6740
e5a67952
MS
6741 type_len = strlen (bptype_string (b->type));
6742 if (type_len > print_type_col_width)
6743 print_type_col_width = type_len;
6744
6745 nr_printable_breakpoints++;
6746 }
6747 }
7f3b0473 6748
79a45b7d 6749 if (opts.addressprint)
3b31d625 6750 bkpttbl_chain
3e43a32a
MS
6751 = make_cleanup_ui_out_table_begin_end (uiout, 6,
6752 nr_printable_breakpoints,
3b31d625 6753 "BreakpointTable");
8b93c638 6754 else
3b31d625 6755 bkpttbl_chain
3e43a32a
MS
6756 = make_cleanup_ui_out_table_begin_end (uiout, 5,
6757 nr_printable_breakpoints,
3b31d625 6758 "BreakpointTable");
8b93c638 6759
7f3b0473 6760 if (nr_printable_breakpoints > 0)
d7faa9e7
AC
6761 annotate_breakpoints_headers ();
6762 if (nr_printable_breakpoints > 0)
6763 annotate_field (0);
4a64f543 6764 ui_out_table_header (uiout, 7, ui_left, "number", "Num"); /* 1 */
d7faa9e7
AC
6765 if (nr_printable_breakpoints > 0)
6766 annotate_field (1);
269b11a2 6767 ui_out_table_header (uiout, print_type_col_width, ui_left,
4a64f543 6768 "type", "Type"); /* 2 */
d7faa9e7
AC
6769 if (nr_printable_breakpoints > 0)
6770 annotate_field (2);
4a64f543 6771 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
d7faa9e7
AC
6772 if (nr_printable_breakpoints > 0)
6773 annotate_field (3);
54e52265 6774 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
79a45b7d 6775 if (opts.addressprint)
e5a67952
MS
6776 {
6777 if (nr_printable_breakpoints > 0)
6778 annotate_field (4);
6779 if (print_address_bits <= 32)
6780 ui_out_table_header (uiout, 10, ui_left,
6781 "addr", "Address"); /* 5 */
6782 else
6783 ui_out_table_header (uiout, 18, ui_left,
6784 "addr", "Address"); /* 5 */
6785 }
d7faa9e7
AC
6786 if (nr_printable_breakpoints > 0)
6787 annotate_field (5);
6788 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
6789 ui_out_table_body (uiout);
6790 if (nr_printable_breakpoints > 0)
6791 annotate_breakpoints_table ();
7f3b0473 6792
c4093a6a 6793 ALL_BREAKPOINTS (b)
e5a67952
MS
6794 {
6795 QUIT;
6796 /* If we have a filter, only list the breakpoints it accepts. */
6797 if (filter && !filter (b))
6798 continue;
6799
6800 /* If we have an "args" string, it is a list of breakpoints to
6801 accept. Skip the others. */
6802
6803 if (args != NULL && *args != '\0')
6804 {
6805 if (allflag) /* maintenance info breakpoint */
6806 {
6807 if (parse_and_eval_long (args) != b->number)
6808 continue;
6809 }
6810 else /* all others */
6811 {
6812 if (!number_is_in_list (args, b->number))
6813 continue;
6814 }
6815 }
6816 /* We only print out user settable breakpoints unless the
6817 allflag is set. */
6818 if (allflag || user_breakpoint_p (b))
12c5a436 6819 print_one_breakpoint (b, &last_loc, allflag);
e5a67952
MS
6820 }
6821
3b31d625 6822 do_cleanups (bkpttbl_chain);
698384cd 6823
7f3b0473 6824 if (nr_printable_breakpoints == 0)
c906108c 6825 {
4a64f543
MS
6826 /* If there's a filter, let the caller decide how to report
6827 empty list. */
d77f58be
SS
6828 if (!filter)
6829 {
e5a67952 6830 if (args == NULL || *args == '\0')
d77f58be
SS
6831 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
6832 else
4a64f543 6833 ui_out_message (uiout, 0,
e5a67952
MS
6834 "No breakpoint or watchpoint matching '%s'.\n",
6835 args);
d77f58be 6836 }
c906108c
SS
6837 }
6838 else
c4093a6a 6839 {
a6d9a66e
UW
6840 if (last_loc && !server_command)
6841 set_next_address (last_loc->gdbarch, last_loc->address);
c4093a6a 6842 }
c906108c 6843
4a64f543 6844 /* FIXME? Should this be moved up so that it is only called when
c4093a6a 6845 there have been breakpoints? */
c906108c 6846 annotate_breakpoints_table_end ();
d77f58be
SS
6847
6848 return nr_printable_breakpoints;
c906108c
SS
6849}
6850
ad443146
SS
6851/* Display the value of default-collect in a way that is generally
6852 compatible with the breakpoint list. */
6853
6854static void
6855default_collect_info (void)
6856{
79a45e25
PA
6857 struct ui_out *uiout = current_uiout;
6858
ad443146
SS
6859 /* If it has no value (which is frequently the case), say nothing; a
6860 message like "No default-collect." gets in user's face when it's
6861 not wanted. */
6862 if (!*default_collect)
6863 return;
6864
6865 /* The following phrase lines up nicely with per-tracepoint collect
6866 actions. */
6867 ui_out_text (uiout, "default collect ");
6868 ui_out_field_string (uiout, "default-collect", default_collect);
6869 ui_out_text (uiout, " \n");
6870}
6871
c906108c 6872static void
e5a67952 6873breakpoints_info (char *args, int from_tty)
c906108c 6874{
e5a67952 6875 breakpoint_1 (args, 0, NULL);
ad443146
SS
6876
6877 default_collect_info ();
d77f58be
SS
6878}
6879
6880static void
e5a67952 6881watchpoints_info (char *args, int from_tty)
d77f58be 6882{
e5a67952 6883 int num_printed = breakpoint_1 (args, 0, is_watchpoint);
79a45e25 6884 struct ui_out *uiout = current_uiout;
d77f58be
SS
6885
6886 if (num_printed == 0)
6887 {
e5a67952 6888 if (args == NULL || *args == '\0')
d77f58be
SS
6889 ui_out_message (uiout, 0, "No watchpoints.\n");
6890 else
e5a67952 6891 ui_out_message (uiout, 0, "No watchpoint matching '%s'.\n", args);
d77f58be 6892 }
c906108c
SS
6893}
6894
7a292a7a 6895static void
e5a67952 6896maintenance_info_breakpoints (char *args, int from_tty)
c906108c 6897{
e5a67952 6898 breakpoint_1 (args, 1, NULL);
ad443146
SS
6899
6900 default_collect_info ();
c906108c
SS
6901}
6902
0d381245 6903static int
714835d5 6904breakpoint_has_pc (struct breakpoint *b,
6c95b8df 6905 struct program_space *pspace,
714835d5 6906 CORE_ADDR pc, struct obj_section *section)
0d381245
VP
6907{
6908 struct bp_location *bl = b->loc;
cc59ec59 6909
0d381245
VP
6910 for (; bl; bl = bl->next)
6911 {
6c95b8df
PA
6912 if (bl->pspace == pspace
6913 && bl->address == pc
0d381245
VP
6914 && (!overlay_debugging || bl->section == section))
6915 return 1;
6916 }
6917 return 0;
6918}
6919
672f9b60 6920/* Print a message describing any user-breakpoints set at PC. This
6c95b8df
PA
6921 concerns with logical breakpoints, so we match program spaces, not
6922 address spaces. */
c906108c
SS
6923
6924static void
6c95b8df
PA
6925describe_other_breakpoints (struct gdbarch *gdbarch,
6926 struct program_space *pspace, CORE_ADDR pc,
5af949e3 6927 struct obj_section *section, int thread)
c906108c 6928{
52f0bd74
AC
6929 int others = 0;
6930 struct breakpoint *b;
c906108c
SS
6931
6932 ALL_BREAKPOINTS (b)
672f9b60
KP
6933 others += (user_breakpoint_p (b)
6934 && breakpoint_has_pc (b, pspace, pc, section));
c906108c
SS
6935 if (others > 0)
6936 {
a3f17187
AC
6937 if (others == 1)
6938 printf_filtered (_("Note: breakpoint "));
6939 else /* if (others == ???) */
6940 printf_filtered (_("Note: breakpoints "));
c906108c 6941 ALL_BREAKPOINTS (b)
672f9b60 6942 if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
0d381245
VP
6943 {
6944 others--;
6945 printf_filtered ("%d", b->number);
6946 if (b->thread == -1 && thread != -1)
6947 printf_filtered (" (all threads)");
6948 else if (b->thread != -1)
6949 printf_filtered (" (thread %d)", b->thread);
6950 printf_filtered ("%s%s ",
059fb39f 6951 ((b->enable_state == bp_disabled
f8eba3c6 6952 || b->enable_state == bp_call_disabled)
0d381245 6953 ? " (disabled)"
0d381245
VP
6954 : ""),
6955 (others > 1) ? ","
6956 : ((others == 1) ? " and" : ""));
6957 }
a3f17187 6958 printf_filtered (_("also set at pc "));
5af949e3 6959 fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
c906108c
SS
6960 printf_filtered (".\n");
6961 }
6962}
6963\f
c906108c 6964
e4f237da 6965/* Return true iff it is meaningful to use the address member of
244558af
LM
6966 BPT locations. For some breakpoint types, the locations' address members
6967 are irrelevant and it makes no sense to attempt to compare them to other
6968 addresses (or use them for any other purpose either).
e4f237da 6969
4a64f543 6970 More specifically, each of the following breakpoint types will
244558af 6971 always have a zero valued location address and we don't want to mark
4a64f543 6972 breakpoints of any of these types to be a duplicate of an actual
244558af 6973 breakpoint location at address zero:
e4f237da
KB
6974
6975 bp_watchpoint
2d134ed3
PA
6976 bp_catchpoint
6977
6978*/
e4f237da
KB
6979
6980static int
6981breakpoint_address_is_meaningful (struct breakpoint *bpt)
6982{
6983 enum bptype type = bpt->type;
6984
2d134ed3
PA
6985 return (type != bp_watchpoint && type != bp_catchpoint);
6986}
6987
6988/* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6989 true if LOC1 and LOC2 represent the same watchpoint location. */
6990
6991static int
4a64f543
MS
6992watchpoint_locations_match (struct bp_location *loc1,
6993 struct bp_location *loc2)
2d134ed3 6994{
3a5c3e22
PA
6995 struct watchpoint *w1 = (struct watchpoint *) loc1->owner;
6996 struct watchpoint *w2 = (struct watchpoint *) loc2->owner;
6997
6998 /* Both of them must exist. */
6999 gdb_assert (w1 != NULL);
7000 gdb_assert (w2 != NULL);
2bdf28a0 7001
4a64f543
MS
7002 /* If the target can evaluate the condition expression in hardware,
7003 then we we need to insert both watchpoints even if they are at
7004 the same place. Otherwise the watchpoint will only trigger when
7005 the condition of whichever watchpoint was inserted evaluates to
7006 true, not giving a chance for GDB to check the condition of the
7007 other watchpoint. */
3a5c3e22 7008 if ((w1->cond_exp
4a64f543
MS
7009 && target_can_accel_watchpoint_condition (loc1->address,
7010 loc1->length,
0cf6dd15 7011 loc1->watchpoint_type,
3a5c3e22
PA
7012 w1->cond_exp))
7013 || (w2->cond_exp
4a64f543
MS
7014 && target_can_accel_watchpoint_condition (loc2->address,
7015 loc2->length,
0cf6dd15 7016 loc2->watchpoint_type,
3a5c3e22 7017 w2->cond_exp)))
0cf6dd15
TJB
7018 return 0;
7019
85d721b8
PA
7020 /* Note that this checks the owner's type, not the location's. In
7021 case the target does not support read watchpoints, but does
7022 support access watchpoints, we'll have bp_read_watchpoint
7023 watchpoints with hw_access locations. Those should be considered
7024 duplicates of hw_read locations. The hw_read locations will
7025 become hw_access locations later. */
2d134ed3
PA
7026 return (loc1->owner->type == loc2->owner->type
7027 && loc1->pspace->aspace == loc2->pspace->aspace
7028 && loc1->address == loc2->address
7029 && loc1->length == loc2->length);
e4f237da
KB
7030}
7031
31e77af2 7032/* See breakpoint.h. */
6c95b8df 7033
31e77af2 7034int
6c95b8df
PA
7035breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
7036 struct address_space *aspace2, CORE_ADDR addr2)
7037{
f5656ead 7038 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6c95b8df
PA
7039 || aspace1 == aspace2)
7040 && addr1 == addr2);
7041}
7042
f1310107
TJB
7043/* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7044 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7045 matches ASPACE2. On targets that have global breakpoints, the address
7046 space doesn't really matter. */
7047
7048static int
7049breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
7050 int len1, struct address_space *aspace2,
7051 CORE_ADDR addr2)
7052{
f5656ead 7053 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
f1310107
TJB
7054 || aspace1 == aspace2)
7055 && addr2 >= addr1 && addr2 < addr1 + len1);
7056}
7057
7058/* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7059 a ranged breakpoint. In most targets, a match happens only if ASPACE
7060 matches the breakpoint's address space. On targets that have global
7061 breakpoints, the address space doesn't really matter. */
7062
7063static int
7064breakpoint_location_address_match (struct bp_location *bl,
7065 struct address_space *aspace,
7066 CORE_ADDR addr)
7067{
7068 return (breakpoint_address_match (bl->pspace->aspace, bl->address,
7069 aspace, addr)
7070 || (bl->length
7071 && breakpoint_address_match_range (bl->pspace->aspace,
7072 bl->address, bl->length,
7073 aspace, addr)));
7074}
7075
1e4d1764
YQ
7076/* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7077 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7078 true, otherwise returns false. */
7079
7080static int
7081tracepoint_locations_match (struct bp_location *loc1,
7082 struct bp_location *loc2)
7083{
7084 if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
7085 /* Since tracepoint locations are never duplicated with others', tracepoint
7086 locations at the same address of different tracepoints are regarded as
7087 different locations. */
7088 return (loc1->address == loc2->address && loc1->owner == loc2->owner);
7089 else
7090 return 0;
7091}
7092
2d134ed3
PA
7093/* Assuming LOC1 and LOC2's types' have meaningful target addresses
7094 (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
7095 represent the same location. */
7096
7097static int
4a64f543
MS
7098breakpoint_locations_match (struct bp_location *loc1,
7099 struct bp_location *loc2)
2d134ed3 7100{
2bdf28a0
JK
7101 int hw_point1, hw_point2;
7102
7103 /* Both of them must not be in moribund_locations. */
7104 gdb_assert (loc1->owner != NULL);
7105 gdb_assert (loc2->owner != NULL);
7106
7107 hw_point1 = is_hardware_watchpoint (loc1->owner);
7108 hw_point2 = is_hardware_watchpoint (loc2->owner);
2d134ed3
PA
7109
7110 if (hw_point1 != hw_point2)
7111 return 0;
7112 else if (hw_point1)
7113 return watchpoint_locations_match (loc1, loc2);
1e4d1764
YQ
7114 else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
7115 return tracepoint_locations_match (loc1, loc2);
2d134ed3 7116 else
f1310107
TJB
7117 /* We compare bp_location.length in order to cover ranged breakpoints. */
7118 return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
7119 loc2->pspace->aspace, loc2->address)
7120 && loc1->length == loc2->length);
2d134ed3
PA
7121}
7122
76897487
KB
7123static void
7124breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
7125 int bnum, int have_bnum)
7126{
f63fbe86
MS
7127 /* The longest string possibly returned by hex_string_custom
7128 is 50 chars. These must be at least that big for safety. */
7129 char astr1[64];
7130 char astr2[64];
76897487 7131
bb599908
PH
7132 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
7133 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
76897487 7134 if (have_bnum)
8a3fe4f8 7135 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
76897487
KB
7136 bnum, astr1, astr2);
7137 else
8a3fe4f8 7138 warning (_("Breakpoint address adjusted from %s to %s."), astr1, astr2);
76897487
KB
7139}
7140
4a64f543
MS
7141/* Adjust a breakpoint's address to account for architectural
7142 constraints on breakpoint placement. Return the adjusted address.
7143 Note: Very few targets require this kind of adjustment. For most
7144 targets, this function is simply the identity function. */
76897487
KB
7145
7146static CORE_ADDR
a6d9a66e
UW
7147adjust_breakpoint_address (struct gdbarch *gdbarch,
7148 CORE_ADDR bpaddr, enum bptype bptype)
76897487 7149{
a6d9a66e 7150 if (!gdbarch_adjust_breakpoint_address_p (gdbarch))
76897487
KB
7151 {
7152 /* Very few targets need any kind of breakpoint adjustment. */
7153 return bpaddr;
7154 }
88f7da05
KB
7155 else if (bptype == bp_watchpoint
7156 || bptype == bp_hardware_watchpoint
7157 || bptype == bp_read_watchpoint
7158 || bptype == bp_access_watchpoint
fe798b75 7159 || bptype == bp_catchpoint)
88f7da05
KB
7160 {
7161 /* Watchpoints and the various bp_catch_* eventpoints should not
7162 have their addresses modified. */
7163 return bpaddr;
7164 }
7c16b83e
PA
7165 else if (bptype == bp_single_step)
7166 {
7167 /* Single-step breakpoints should not have their addresses
7168 modified. If there's any architectural constrain that
7169 applies to this address, then it should have already been
7170 taken into account when the breakpoint was created in the
7171 first place. If we didn't do this, stepping through e.g.,
7172 Thumb-2 IT blocks would break. */
7173 return bpaddr;
7174 }
76897487
KB
7175 else
7176 {
7177 CORE_ADDR adjusted_bpaddr;
7178
7179 /* Some targets have architectural constraints on the placement
7180 of breakpoint instructions. Obtain the adjusted address. */
a6d9a66e 7181 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (gdbarch, bpaddr);
76897487
KB
7182
7183 /* An adjusted breakpoint address can significantly alter
7184 a user's expectations. Print a warning if an adjustment
7185 is required. */
7186 if (adjusted_bpaddr != bpaddr)
7187 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
7188
7189 return adjusted_bpaddr;
7190 }
7191}
7192
28010a5d
PA
7193void
7194init_bp_location (struct bp_location *loc, const struct bp_location_ops *ops,
7195 struct breakpoint *owner)
7cc221ef 7196{
7cc221ef
DJ
7197 memset (loc, 0, sizeof (*loc));
7198
348d480f
PA
7199 gdb_assert (ops != NULL);
7200
28010a5d
PA
7201 loc->ops = ops;
7202 loc->owner = owner;
511a6cd4 7203 loc->cond = NULL;
b775012e 7204 loc->cond_bytecode = NULL;
0d381245
VP
7205 loc->shlib_disabled = 0;
7206 loc->enabled = 1;
e049a4b5 7207
28010a5d 7208 switch (owner->type)
e049a4b5
DJ
7209 {
7210 case bp_breakpoint:
7c16b83e 7211 case bp_single_step:
e049a4b5
DJ
7212 case bp_until:
7213 case bp_finish:
7214 case bp_longjmp:
7215 case bp_longjmp_resume:
e2e4d78b 7216 case bp_longjmp_call_dummy:
186c406b
TT
7217 case bp_exception:
7218 case bp_exception_resume:
e049a4b5 7219 case bp_step_resume:
2c03e5be 7220 case bp_hp_step_resume:
e049a4b5
DJ
7221 case bp_watchpoint_scope:
7222 case bp_call_dummy:
aa7d318d 7223 case bp_std_terminate:
e049a4b5
DJ
7224 case bp_shlib_event:
7225 case bp_thread_event:
7226 case bp_overlay_event:
4efc6507 7227 case bp_jit_event:
0fd8e87f 7228 case bp_longjmp_master:
aa7d318d 7229 case bp_std_terminate_master:
186c406b 7230 case bp_exception_master:
0e30163f
JK
7231 case bp_gnu_ifunc_resolver:
7232 case bp_gnu_ifunc_resolver_return:
e7e0cddf 7233 case bp_dprintf:
e049a4b5 7234 loc->loc_type = bp_loc_software_breakpoint;
b775012e 7235 mark_breakpoint_location_modified (loc);
e049a4b5
DJ
7236 break;
7237 case bp_hardware_breakpoint:
7238 loc->loc_type = bp_loc_hardware_breakpoint;
b775012e 7239 mark_breakpoint_location_modified (loc);
e049a4b5
DJ
7240 break;
7241 case bp_hardware_watchpoint:
7242 case bp_read_watchpoint:
7243 case bp_access_watchpoint:
7244 loc->loc_type = bp_loc_hardware_watchpoint;
7245 break;
7246 case bp_watchpoint:
ce78b96d 7247 case bp_catchpoint:
15c3d785
PA
7248 case bp_tracepoint:
7249 case bp_fast_tracepoint:
0fb4aa4b 7250 case bp_static_tracepoint:
e049a4b5
DJ
7251 loc->loc_type = bp_loc_other;
7252 break;
7253 default:
e2e0b3e5 7254 internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
e049a4b5
DJ
7255 }
7256
f431efe5 7257 loc->refc = 1;
28010a5d
PA
7258}
7259
7260/* Allocate a struct bp_location. */
7261
7262static struct bp_location *
7263allocate_bp_location (struct breakpoint *bpt)
7264{
348d480f
PA
7265 return bpt->ops->allocate_location (bpt);
7266}
7cc221ef 7267
f431efe5
PA
7268static void
7269free_bp_location (struct bp_location *loc)
fe3f5fa8 7270{
348d480f 7271 loc->ops->dtor (loc);
fe3f5fa8
VP
7272 xfree (loc);
7273}
7274
f431efe5
PA
7275/* Increment reference count. */
7276
7277static void
7278incref_bp_location (struct bp_location *bl)
7279{
7280 ++bl->refc;
7281}
7282
7283/* Decrement reference count. If the reference count reaches 0,
7284 destroy the bp_location. Sets *BLP to NULL. */
7285
7286static void
7287decref_bp_location (struct bp_location **blp)
7288{
0807b50c
PA
7289 gdb_assert ((*blp)->refc > 0);
7290
f431efe5
PA
7291 if (--(*blp)->refc == 0)
7292 free_bp_location (*blp);
7293 *blp = NULL;
7294}
7295
346774a9 7296/* Add breakpoint B at the end of the global breakpoint chain. */
c906108c 7297
346774a9
PA
7298static void
7299add_to_breakpoint_chain (struct breakpoint *b)
c906108c 7300{
346774a9 7301 struct breakpoint *b1;
c906108c 7302
346774a9
PA
7303 /* Add this breakpoint to the end of the chain so that a list of
7304 breakpoints will come out in order of increasing numbers. */
7305
7306 b1 = breakpoint_chain;
7307 if (b1 == 0)
7308 breakpoint_chain = b;
7309 else
7310 {
7311 while (b1->next)
7312 b1 = b1->next;
7313 b1->next = b;
7314 }
7315}
7316
7317/* Initializes breakpoint B with type BPTYPE and no locations yet. */
7318
7319static void
7320init_raw_breakpoint_without_location (struct breakpoint *b,
7321 struct gdbarch *gdbarch,
28010a5d 7322 enum bptype bptype,
c0a91b2b 7323 const struct breakpoint_ops *ops)
346774a9 7324{
c906108c 7325 memset (b, 0, sizeof (*b));
2219d63c 7326
348d480f
PA
7327 gdb_assert (ops != NULL);
7328
28010a5d 7329 b->ops = ops;
4d28f7a8 7330 b->type = bptype;
a6d9a66e 7331 b->gdbarch = gdbarch;
c906108c
SS
7332 b->language = current_language->la_language;
7333 b->input_radix = input_radix;
7334 b->thread = -1;
b5de0fa7 7335 b->enable_state = bp_enabled;
c906108c
SS
7336 b->next = 0;
7337 b->silent = 0;
7338 b->ignore_count = 0;
7339 b->commands = NULL;
818dd999 7340 b->frame_id = null_frame_id;
0d381245 7341 b->condition_not_parsed = 0;
84f4c1fe 7342 b->py_bp_object = NULL;
d0fb5eae 7343 b->related_breakpoint = b;
f00aae0f 7344 b->location = NULL;
346774a9
PA
7345}
7346
7347/* Helper to set_raw_breakpoint below. Creates a breakpoint
7348 that has type BPTYPE and has no locations as yet. */
346774a9
PA
7349
7350static struct breakpoint *
7351set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
348d480f 7352 enum bptype bptype,
c0a91b2b 7353 const struct breakpoint_ops *ops)
346774a9
PA
7354{
7355 struct breakpoint *b = XNEW (struct breakpoint);
7356
348d480f 7357 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
c56053d2 7358 add_to_breakpoint_chain (b);
0d381245
VP
7359 return b;
7360}
7361
0e30163f
JK
7362/* Initialize loc->function_name. EXPLICIT_LOC says no indirect function
7363 resolutions should be made as the user specified the location explicitly
7364 enough. */
7365
0d381245 7366static void
0e30163f 7367set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
0d381245 7368{
2bdf28a0
JK
7369 gdb_assert (loc->owner != NULL);
7370
0d381245 7371 if (loc->owner->type == bp_breakpoint
1042e4c0 7372 || loc->owner->type == bp_hardware_breakpoint
d77f58be 7373 || is_tracepoint (loc->owner))
0d381245 7374 {
0e30163f 7375 int is_gnu_ifunc;
2c02bd72 7376 const char *function_name;
6a3a010b 7377 CORE_ADDR func_addr;
0e30163f 7378
2c02bd72 7379 find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
6a3a010b 7380 &func_addr, NULL, &is_gnu_ifunc);
0e30163f
JK
7381
7382 if (is_gnu_ifunc && !explicit_loc)
7383 {
7384 struct breakpoint *b = loc->owner;
7385
7386 gdb_assert (loc->pspace == current_program_space);
2c02bd72 7387 if (gnu_ifunc_resolve_name (function_name,
0e30163f
JK
7388 &loc->requested_address))
7389 {
7390 /* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
7391 loc->address = adjust_breakpoint_address (loc->gdbarch,
7392 loc->requested_address,
7393 b->type);
7394 }
7395 else if (b->type == bp_breakpoint && b->loc == loc
7396 && loc->next == NULL && b->related_breakpoint == b)
7397 {
7398 /* Create only the whole new breakpoint of this type but do not
7399 mess more complicated breakpoints with multiple locations. */
7400 b->type = bp_gnu_ifunc_resolver;
6a3a010b
MR
7401 /* Remember the resolver's address for use by the return
7402 breakpoint. */
7403 loc->related_address = func_addr;
0e30163f
JK
7404 }
7405 }
7406
2c02bd72
DE
7407 if (function_name)
7408 loc->function_name = xstrdup (function_name);
0d381245
VP
7409 }
7410}
7411
a6d9a66e 7412/* Attempt to determine architecture of location identified by SAL. */
1bfeeb0f 7413struct gdbarch *
a6d9a66e
UW
7414get_sal_arch (struct symtab_and_line sal)
7415{
7416 if (sal.section)
7417 return get_objfile_arch (sal.section->objfile);
7418 if (sal.symtab)
eb822aa6 7419 return get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
a6d9a66e
UW
7420
7421 return NULL;
7422}
7423
346774a9
PA
7424/* Low level routine for partially initializing a breakpoint of type
7425 BPTYPE. The newly created breakpoint's address, section, source
c56053d2 7426 file name, and line number are provided by SAL.
0d381245
VP
7427
7428 It is expected that the caller will complete the initialization of
7429 the newly created breakpoint struct as well as output any status
c56053d2 7430 information regarding the creation of a new breakpoint. */
0d381245 7431
346774a9
PA
7432static void
7433init_raw_breakpoint (struct breakpoint *b, struct gdbarch *gdbarch,
28010a5d 7434 struct symtab_and_line sal, enum bptype bptype,
c0a91b2b 7435 const struct breakpoint_ops *ops)
0d381245 7436{
28010a5d 7437 init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
346774a9 7438
3742cc8b 7439 add_location_to_breakpoint (b, &sal);
0d381245 7440
6c95b8df
PA
7441 if (bptype != bp_catchpoint)
7442 gdb_assert (sal.pspace != NULL);
7443
f8eba3c6
TT
7444 /* Store the program space that was used to set the breakpoint,
7445 except for ordinary breakpoints, which are independent of the
7446 program space. */
7447 if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
7448 b->pspace = sal.pspace;
346774a9 7449}
c906108c 7450
346774a9
PA
7451/* set_raw_breakpoint is a low level routine for allocating and
7452 partially initializing a breakpoint of type BPTYPE. The newly
7453 created breakpoint's address, section, source file name, and line
7454 number are provided by SAL. The newly created and partially
7455 initialized breakpoint is added to the breakpoint chain and
7456 is also returned as the value of this function.
7457
7458 It is expected that the caller will complete the initialization of
7459 the newly created breakpoint struct as well as output any status
7460 information regarding the creation of a new breakpoint. In
7461 particular, set_raw_breakpoint does NOT set the breakpoint
7462 number! Care should be taken to not allow an error to occur
7463 prior to completing the initialization of the breakpoint. If this
7464 should happen, a bogus breakpoint will be left on the chain. */
7465
7466struct breakpoint *
7467set_raw_breakpoint (struct gdbarch *gdbarch,
348d480f 7468 struct symtab_and_line sal, enum bptype bptype,
c0a91b2b 7469 const struct breakpoint_ops *ops)
346774a9
PA
7470{
7471 struct breakpoint *b = XNEW (struct breakpoint);
7472
348d480f 7473 init_raw_breakpoint (b, gdbarch, sal, bptype, ops);
c56053d2 7474 add_to_breakpoint_chain (b);
c906108c
SS
7475 return b;
7476}
7477
53a5351d 7478/* Call this routine when stepping and nexting to enable a breakpoint
186c406b
TT
7479 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7480 initiated the operation. */
c906108c
SS
7481
7482void
186c406b 7483set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
c906108c 7484{
35df4500 7485 struct breakpoint *b, *b_tmp;
186c406b 7486 int thread = tp->num;
0fd8e87f
UW
7487
7488 /* To avoid having to rescan all objfile symbols at every step,
7489 we maintain a list of continually-inserted but always disabled
7490 longjmp "master" breakpoints. Here, we simply create momentary
7491 clones of those and enable them for the requested thread. */
35df4500 7492 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6c95b8df 7493 if (b->pspace == current_program_space
186c406b
TT
7494 && (b->type == bp_longjmp_master
7495 || b->type == bp_exception_master))
0fd8e87f 7496 {
06edf0c0
PA
7497 enum bptype type = b->type == bp_longjmp_master ? bp_longjmp : bp_exception;
7498 struct breakpoint *clone;
cc59ec59 7499
e2e4d78b
JK
7500 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7501 after their removal. */
06edf0c0 7502 clone = momentary_breakpoint_from_master (b, type,
a1aa2221 7503 &longjmp_breakpoint_ops, 1);
0fd8e87f
UW
7504 clone->thread = thread;
7505 }
186c406b
TT
7506
7507 tp->initiating_frame = frame;
c906108c
SS
7508}
7509
611c83ae 7510/* Delete all longjmp breakpoints from THREAD. */
c906108c 7511void
611c83ae 7512delete_longjmp_breakpoint (int thread)
c906108c 7513{
35df4500 7514 struct breakpoint *b, *b_tmp;
c906108c 7515
35df4500 7516 ALL_BREAKPOINTS_SAFE (b, b_tmp)
186c406b 7517 if (b->type == bp_longjmp || b->type == bp_exception)
611c83ae
PA
7518 {
7519 if (b->thread == thread)
7520 delete_breakpoint (b);
7521 }
c906108c
SS
7522}
7523
f59f708a
PA
7524void
7525delete_longjmp_breakpoint_at_next_stop (int thread)
7526{
7527 struct breakpoint *b, *b_tmp;
7528
7529 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7530 if (b->type == bp_longjmp || b->type == bp_exception)
7531 {
7532 if (b->thread == thread)
7533 b->disposition = disp_del_at_next_stop;
7534 }
7535}
7536
e2e4d78b
JK
7537/* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7538 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7539 pointer to any of them. Return NULL if this system cannot place longjmp
7540 breakpoints. */
7541
7542struct breakpoint *
7543set_longjmp_breakpoint_for_call_dummy (void)
7544{
7545 struct breakpoint *b, *retval = NULL;
7546
7547 ALL_BREAKPOINTS (b)
7548 if (b->pspace == current_program_space && b->type == bp_longjmp_master)
7549 {
7550 struct breakpoint *new_b;
7551
7552 new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
a1aa2221
LM
7553 &momentary_breakpoint_ops,
7554 1);
e2e4d78b
JK
7555 new_b->thread = pid_to_thread_id (inferior_ptid);
7556
7557 /* Link NEW_B into the chain of RETVAL breakpoints. */
7558
7559 gdb_assert (new_b->related_breakpoint == new_b);
7560 if (retval == NULL)
7561 retval = new_b;
7562 new_b->related_breakpoint = retval;
7563 while (retval->related_breakpoint != new_b->related_breakpoint)
7564 retval = retval->related_breakpoint;
7565 retval->related_breakpoint = new_b;
7566 }
7567
7568 return retval;
7569}
7570
7571/* Verify all existing dummy frames and their associated breakpoints for
b67a2c6f 7572 TP. Remove those which can no longer be found in the current frame
e2e4d78b
JK
7573 stack.
7574
7575 You should call this function only at places where it is safe to currently
7576 unwind the whole stack. Failed stack unwind would discard live dummy
7577 frames. */
7578
7579void
b67a2c6f 7580check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
e2e4d78b
JK
7581{
7582 struct breakpoint *b, *b_tmp;
7583
7584 ALL_BREAKPOINTS_SAFE (b, b_tmp)
b67a2c6f 7585 if (b->type == bp_longjmp_call_dummy && b->thread == tp->num)
e2e4d78b
JK
7586 {
7587 struct breakpoint *dummy_b = b->related_breakpoint;
7588
7589 while (dummy_b != b && dummy_b->type != bp_call_dummy)
7590 dummy_b = dummy_b->related_breakpoint;
7591 if (dummy_b->type != bp_call_dummy
7592 || frame_find_by_id (dummy_b->frame_id) != NULL)
7593 continue;
7594
b67a2c6f 7595 dummy_frame_discard (dummy_b->frame_id, tp->ptid);
e2e4d78b
JK
7596
7597 while (b->related_breakpoint != b)
7598 {
7599 if (b_tmp == b->related_breakpoint)
7600 b_tmp = b->related_breakpoint->next;
7601 delete_breakpoint (b->related_breakpoint);
7602 }
7603 delete_breakpoint (b);
7604 }
7605}
7606
1900040c
MS
7607void
7608enable_overlay_breakpoints (void)
7609{
52f0bd74 7610 struct breakpoint *b;
1900040c
MS
7611
7612 ALL_BREAKPOINTS (b)
7613 if (b->type == bp_overlay_event)
7614 {
7615 b->enable_state = bp_enabled;
44702360 7616 update_global_location_list (UGLL_MAY_INSERT);
c02f5703 7617 overlay_events_enabled = 1;
1900040c
MS
7618 }
7619}
7620
7621void
7622disable_overlay_breakpoints (void)
7623{
52f0bd74 7624 struct breakpoint *b;
1900040c
MS
7625
7626 ALL_BREAKPOINTS (b)
7627 if (b->type == bp_overlay_event)
7628 {
7629 b->enable_state = bp_disabled;
44702360 7630 update_global_location_list (UGLL_DONT_INSERT);
c02f5703 7631 overlay_events_enabled = 0;
1900040c
MS
7632 }
7633}
7634
aa7d318d
TT
7635/* Set an active std::terminate breakpoint for each std::terminate
7636 master breakpoint. */
7637void
7638set_std_terminate_breakpoint (void)
7639{
35df4500 7640 struct breakpoint *b, *b_tmp;
aa7d318d 7641
35df4500 7642 ALL_BREAKPOINTS_SAFE (b, b_tmp)
aa7d318d
TT
7643 if (b->pspace == current_program_space
7644 && b->type == bp_std_terminate_master)
7645 {
06edf0c0 7646 momentary_breakpoint_from_master (b, bp_std_terminate,
a1aa2221 7647 &momentary_breakpoint_ops, 1);
aa7d318d
TT
7648 }
7649}
7650
7651/* Delete all the std::terminate breakpoints. */
7652void
7653delete_std_terminate_breakpoint (void)
7654{
35df4500 7655 struct breakpoint *b, *b_tmp;
aa7d318d 7656
35df4500 7657 ALL_BREAKPOINTS_SAFE (b, b_tmp)
aa7d318d
TT
7658 if (b->type == bp_std_terminate)
7659 delete_breakpoint (b);
7660}
7661
c4093a6a 7662struct breakpoint *
a6d9a66e 7663create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
c4093a6a
JM
7664{
7665 struct breakpoint *b;
c4093a6a 7666
06edf0c0
PA
7667 b = create_internal_breakpoint (gdbarch, address, bp_thread_event,
7668 &internal_breakpoint_ops);
7669
b5de0fa7 7670 b->enable_state = bp_enabled;
f00aae0f 7671 /* location has to be used or breakpoint_re_set will delete me. */
a06efdd6 7672 b->location = new_address_location (b->loc->address);
c4093a6a 7673
44702360 7674 update_global_location_list_nothrow (UGLL_MAY_INSERT);
74960c60 7675
c4093a6a
JM
7676 return b;
7677}
7678
7679void
7680remove_thread_event_breakpoints (void)
7681{
35df4500 7682 struct breakpoint *b, *b_tmp;
c4093a6a 7683
35df4500 7684 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6c95b8df
PA
7685 if (b->type == bp_thread_event
7686 && b->loc->pspace == current_program_space)
c4093a6a
JM
7687 delete_breakpoint (b);
7688}
7689
0101ce28
JJ
7690struct lang_and_radix
7691 {
7692 enum language lang;
7693 int radix;
7694 };
7695
4efc6507
DE
7696/* Create a breakpoint for JIT code registration and unregistration. */
7697
7698struct breakpoint *
7699create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7700{
7701 struct breakpoint *b;
7702
06edf0c0
PA
7703 b = create_internal_breakpoint (gdbarch, address, bp_jit_event,
7704 &internal_breakpoint_ops);
44702360 7705 update_global_location_list_nothrow (UGLL_MAY_INSERT);
4efc6507
DE
7706 return b;
7707}
0101ce28 7708
03673fc7
PP
7709/* Remove JIT code registration and unregistration breakpoint(s). */
7710
7711void
7712remove_jit_event_breakpoints (void)
7713{
7714 struct breakpoint *b, *b_tmp;
7715
7716 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7717 if (b->type == bp_jit_event
7718 && b->loc->pspace == current_program_space)
7719 delete_breakpoint (b);
7720}
7721
cae688ec
JJ
7722void
7723remove_solib_event_breakpoints (void)
7724{
35df4500 7725 struct breakpoint *b, *b_tmp;
cae688ec 7726
35df4500 7727 ALL_BREAKPOINTS_SAFE (b, b_tmp)
6c95b8df
PA
7728 if (b->type == bp_shlib_event
7729 && b->loc->pspace == current_program_space)
cae688ec
JJ
7730 delete_breakpoint (b);
7731}
7732
f37f681c
PA
7733/* See breakpoint.h. */
7734
7735void
7736remove_solib_event_breakpoints_at_next_stop (void)
7737{
7738 struct breakpoint *b, *b_tmp;
7739
7740 ALL_BREAKPOINTS_SAFE (b, b_tmp)
7741 if (b->type == bp_shlib_event
7742 && b->loc->pspace == current_program_space)
7743 b->disposition = disp_del_at_next_stop;
7744}
7745
04086b45
PA
7746/* Helper for create_solib_event_breakpoint /
7747 create_and_insert_solib_event_breakpoint. Allows specifying which
7748 INSERT_MODE to pass through to update_global_location_list. */
7749
7750static struct breakpoint *
7751create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
7752 enum ugll_insert_mode insert_mode)
cae688ec
JJ
7753{
7754 struct breakpoint *b;
7755
06edf0c0
PA
7756 b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
7757 &internal_breakpoint_ops);
04086b45 7758 update_global_location_list_nothrow (insert_mode);
cae688ec
JJ
7759 return b;
7760}
7761
04086b45
PA
7762struct breakpoint *
7763create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7764{
7765 return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
7766}
7767
f37f681c
PA
7768/* See breakpoint.h. */
7769
7770struct breakpoint *
7771create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
7772{
7773 struct breakpoint *b;
7774
04086b45
PA
7775 /* Explicitly tell update_global_location_list to insert
7776 locations. */
7777 b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
f37f681c
PA
7778 if (!b->loc->inserted)
7779 {
7780 delete_breakpoint (b);
7781 return NULL;
7782 }
7783 return b;
7784}
7785
cae688ec
JJ
7786/* Disable any breakpoints that are on code in shared libraries. Only
7787 apply to enabled breakpoints, disabled ones can just stay disabled. */
7788
7789void
cb851954 7790disable_breakpoints_in_shlibs (void)
cae688ec 7791{
876fa593 7792 struct bp_location *loc, **locp_tmp;
cae688ec 7793
876fa593 7794 ALL_BP_LOCATIONS (loc, locp_tmp)
cae688ec 7795 {
2bdf28a0 7796 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
0d381245 7797 struct breakpoint *b = loc->owner;
2bdf28a0 7798
4a64f543
MS
7799 /* We apply the check to all breakpoints, including disabled for
7800 those with loc->duplicate set. This is so that when breakpoint
7801 becomes enabled, or the duplicate is removed, gdb will try to
7802 insert all breakpoints. If we don't set shlib_disabled here,
7803 we'll try to insert those breakpoints and fail. */
1042e4c0 7804 if (((b->type == bp_breakpoint)
508ccb1f 7805 || (b->type == bp_jit_event)
1042e4c0 7806 || (b->type == bp_hardware_breakpoint)
d77f58be 7807 || (is_tracepoint (b)))
6c95b8df 7808 && loc->pspace == current_program_space
0d381245 7809 && !loc->shlib_disabled
6c95b8df 7810 && solib_name_from_address (loc->pspace, loc->address)
a77053c2 7811 )
0d381245
VP
7812 {
7813 loc->shlib_disabled = 1;
7814 }
cae688ec
JJ
7815 }
7816}
7817
63644780
NB
7818/* Disable any breakpoints and tracepoints that are in SOLIB upon
7819 notification of unloaded_shlib. Only apply to enabled breakpoints,
7820 disabled ones can just stay disabled. */
84acb35a 7821
75149521 7822static void
84acb35a
JJ
7823disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
7824{
876fa593 7825 struct bp_location *loc, **locp_tmp;
84acb35a
JJ
7826 int disabled_shlib_breaks = 0;
7827
c86cf029
VP
7828 /* SunOS a.out shared libraries are always mapped, so do not
7829 disable breakpoints; they will only be reported as unloaded
7830 through clear_solib when GDB discards its shared library
7831 list. See clear_solib for more information. */
7832 if (exec_bfd != NULL
7833 && bfd_get_flavour (exec_bfd) == bfd_target_aout_flavour)
7834 return;
7835
876fa593 7836 ALL_BP_LOCATIONS (loc, locp_tmp)
84acb35a 7837 {
2bdf28a0 7838 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
0d381245 7839 struct breakpoint *b = loc->owner;
cc59ec59 7840
1e4d1764 7841 if (solib->pspace == loc->pspace
e2dd7057 7842 && !loc->shlib_disabled
1e4d1764
YQ
7843 && (((b->type == bp_breakpoint
7844 || b->type == bp_jit_event
7845 || b->type == bp_hardware_breakpoint)
7846 && (loc->loc_type == bp_loc_hardware_breakpoint
7847 || loc->loc_type == bp_loc_software_breakpoint))
7848 || is_tracepoint (b))
e2dd7057 7849 && solib_contains_address_p (solib, loc->address))
84acb35a 7850 {
e2dd7057
PP
7851 loc->shlib_disabled = 1;
7852 /* At this point, we cannot rely on remove_breakpoint
7853 succeeding so we must mark the breakpoint as not inserted
7854 to prevent future errors occurring in remove_breakpoints. */
7855 loc->inserted = 0;
8d3788bd
VP
7856
7857 /* This may cause duplicate notifications for the same breakpoint. */
7858 observer_notify_breakpoint_modified (b);
7859
e2dd7057
PP
7860 if (!disabled_shlib_breaks)
7861 {
7862 target_terminal_ours_for_output ();
3e43a32a
MS
7863 warning (_("Temporarily disabling breakpoints "
7864 "for unloaded shared library \"%s\""),
e2dd7057 7865 solib->so_name);
84acb35a 7866 }
e2dd7057 7867 disabled_shlib_breaks = 1;
84acb35a
JJ
7868 }
7869 }
84acb35a
JJ
7870}
7871
63644780
NB
7872/* Disable any breakpoints and tracepoints in OBJFILE upon
7873 notification of free_objfile. Only apply to enabled breakpoints,
7874 disabled ones can just stay disabled. */
7875
7876static void
7877disable_breakpoints_in_freed_objfile (struct objfile *objfile)
7878{
7879 struct breakpoint *b;
7880
7881 if (objfile == NULL)
7882 return;
7883
d03de421
PA
7884 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7885 managed by the user with add-symbol-file/remove-symbol-file.
7886 Similarly to how breakpoints in shared libraries are handled in
7887 response to "nosharedlibrary", mark breakpoints in such modules
08351840
PA
7888 shlib_disabled so they end up uninserted on the next global
7889 location list update. Shared libraries not loaded by the user
7890 aren't handled here -- they're already handled in
7891 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7892 solib_unloaded observer. We skip objfiles that are not
d03de421
PA
7893 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7894 main objfile). */
7895 if ((objfile->flags & OBJF_SHARED) == 0
7896 || (objfile->flags & OBJF_USERLOADED) == 0)
63644780
NB
7897 return;
7898
7899 ALL_BREAKPOINTS (b)
7900 {
7901 struct bp_location *loc;
7902 int bp_modified = 0;
7903
7904 if (!is_breakpoint (b) && !is_tracepoint (b))
7905 continue;
7906
7907 for (loc = b->loc; loc != NULL; loc = loc->next)
7908 {
7909 CORE_ADDR loc_addr = loc->address;
7910
7911 if (loc->loc_type != bp_loc_hardware_breakpoint
7912 && loc->loc_type != bp_loc_software_breakpoint)
7913 continue;
7914
7915 if (loc->shlib_disabled != 0)
7916 continue;
7917
7918 if (objfile->pspace != loc->pspace)
7919 continue;
7920
7921 if (loc->loc_type != bp_loc_hardware_breakpoint
7922 && loc->loc_type != bp_loc_software_breakpoint)
7923 continue;
7924
7925 if (is_addr_in_objfile (loc_addr, objfile))
7926 {
7927 loc->shlib_disabled = 1;
08351840
PA
7928 /* At this point, we don't know whether the object was
7929 unmapped from the inferior or not, so leave the
7930 inserted flag alone. We'll handle failure to
7931 uninsert quietly, in case the object was indeed
7932 unmapped. */
63644780
NB
7933
7934 mark_breakpoint_location_modified (loc);
7935
7936 bp_modified = 1;
7937 }
7938 }
7939
7940 if (bp_modified)
7941 observer_notify_breakpoint_modified (b);
7942 }
7943}
7944
ce78b96d
JB
7945/* FORK & VFORK catchpoints. */
7946
e29a4733
PA
7947/* An instance of this type is used to represent a fork or vfork
7948 catchpoint. It includes a "struct breakpoint" as a kind of base
7949 class; users downcast to "struct breakpoint *" when needed. A
7950 breakpoint is really of this type iff its ops pointer points to
7951 CATCH_FORK_BREAKPOINT_OPS. */
7952
7953struct fork_catchpoint
7954{
7955 /* The base class. */
7956 struct breakpoint base;
7957
7958 /* Process id of a child process whose forking triggered this
7959 catchpoint. This field is only valid immediately after this
7960 catchpoint has triggered. */
7961 ptid_t forked_inferior_pid;
7962};
7963
4a64f543
MS
7964/* Implement the "insert" breakpoint_ops method for fork
7965 catchpoints. */
ce78b96d 7966
77b06cd7
TJB
7967static int
7968insert_catch_fork (struct bp_location *bl)
ce78b96d 7969{
dfd4cc63 7970 return target_insert_fork_catchpoint (ptid_get_pid (inferior_ptid));
ce78b96d
JB
7971}
7972
4a64f543
MS
7973/* Implement the "remove" breakpoint_ops method for fork
7974 catchpoints. */
ce78b96d
JB
7975
7976static int
77b06cd7 7977remove_catch_fork (struct bp_location *bl)
ce78b96d 7978{
dfd4cc63 7979 return target_remove_fork_catchpoint (ptid_get_pid (inferior_ptid));
ce78b96d
JB
7980}
7981
7982/* Implement the "breakpoint_hit" breakpoint_ops method for fork
7983 catchpoints. */
7984
7985static int
f1310107 7986breakpoint_hit_catch_fork (const struct bp_location *bl,
09ac7c10
TT
7987 struct address_space *aspace, CORE_ADDR bp_addr,
7988 const struct target_waitstatus *ws)
ce78b96d 7989{
e29a4733
PA
7990 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
7991
f90263c1
TT
7992 if (ws->kind != TARGET_WAITKIND_FORKED)
7993 return 0;
7994
7995 c->forked_inferior_pid = ws->value.related_pid;
7996 return 1;
ce78b96d
JB
7997}
7998
4a64f543
MS
7999/* Implement the "print_it" breakpoint_ops method for fork
8000 catchpoints. */
ce78b96d
JB
8001
8002static enum print_stop_action
348d480f 8003print_it_catch_fork (bpstat bs)
ce78b96d 8004{
36dfb11c 8005 struct ui_out *uiout = current_uiout;
348d480f
PA
8006 struct breakpoint *b = bs->breakpoint_at;
8007 struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
e29a4733 8008
ce78b96d 8009 annotate_catchpoint (b->number);
36dfb11c
TT
8010 if (b->disposition == disp_del)
8011 ui_out_text (uiout, "\nTemporary catchpoint ");
8012 else
8013 ui_out_text (uiout, "\nCatchpoint ");
8014 if (ui_out_is_mi_like_p (uiout))
8015 {
8016 ui_out_field_string (uiout, "reason",
8017 async_reason_lookup (EXEC_ASYNC_FORK));
8018 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8019 }
8020 ui_out_field_int (uiout, "bkptno", b->number);
8021 ui_out_text (uiout, " (forked process ");
8022 ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
8023 ui_out_text (uiout, "), ");
ce78b96d
JB
8024 return PRINT_SRC_AND_LOC;
8025}
8026
4a64f543
MS
8027/* Implement the "print_one" breakpoint_ops method for fork
8028 catchpoints. */
ce78b96d
JB
8029
8030static void
a6d9a66e 8031print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
ce78b96d 8032{
e29a4733 8033 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
79a45b7d 8034 struct value_print_options opts;
79a45e25 8035 struct ui_out *uiout = current_uiout;
79a45b7d
TT
8036
8037 get_user_print_options (&opts);
8038
4a64f543
MS
8039 /* Field 4, the address, is omitted (which makes the columns not
8040 line up too nicely with the headers, but the effect is relatively
8041 readable). */
79a45b7d 8042 if (opts.addressprint)
ce78b96d
JB
8043 ui_out_field_skip (uiout, "addr");
8044 annotate_field (5);
8045 ui_out_text (uiout, "fork");
e29a4733 8046 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
ce78b96d
JB
8047 {
8048 ui_out_text (uiout, ", process ");
8049 ui_out_field_int (uiout, "what",
e29a4733 8050 ptid_get_pid (c->forked_inferior_pid));
ce78b96d
JB
8051 ui_out_spaces (uiout, 1);
8052 }
8ac3646f
TT
8053
8054 if (ui_out_is_mi_like_p (uiout))
8055 ui_out_field_string (uiout, "catch-type", "fork");
ce78b96d
JB
8056}
8057
8058/* Implement the "print_mention" breakpoint_ops method for fork
8059 catchpoints. */
8060
8061static void
8062print_mention_catch_fork (struct breakpoint *b)
8063{
8064 printf_filtered (_("Catchpoint %d (fork)"), b->number);
8065}
8066
6149aea9
PA
8067/* Implement the "print_recreate" breakpoint_ops method for fork
8068 catchpoints. */
8069
8070static void
8071print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
8072{
8073 fprintf_unfiltered (fp, "catch fork");
d9b3f62e 8074 print_recreate_thread (b, fp);
6149aea9
PA
8075}
8076
ce78b96d
JB
8077/* The breakpoint_ops structure to be used in fork catchpoints. */
8078
2060206e 8079static struct breakpoint_ops catch_fork_breakpoint_ops;
ce78b96d 8080
4a64f543
MS
8081/* Implement the "insert" breakpoint_ops method for vfork
8082 catchpoints. */
ce78b96d 8083
77b06cd7
TJB
8084static int
8085insert_catch_vfork (struct bp_location *bl)
ce78b96d 8086{
dfd4cc63 8087 return target_insert_vfork_catchpoint (ptid_get_pid (inferior_ptid));
ce78b96d
JB
8088}
8089
4a64f543
MS
8090/* Implement the "remove" breakpoint_ops method for vfork
8091 catchpoints. */
ce78b96d
JB
8092
8093static int
77b06cd7 8094remove_catch_vfork (struct bp_location *bl)
ce78b96d 8095{
dfd4cc63 8096 return target_remove_vfork_catchpoint (ptid_get_pid (inferior_ptid));
ce78b96d
JB
8097}
8098
8099/* Implement the "breakpoint_hit" breakpoint_ops method for vfork
8100 catchpoints. */
8101
8102static int
f1310107 8103breakpoint_hit_catch_vfork (const struct bp_location *bl,
09ac7c10
TT
8104 struct address_space *aspace, CORE_ADDR bp_addr,
8105 const struct target_waitstatus *ws)
ce78b96d 8106{
e29a4733
PA
8107 struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
8108
f90263c1
TT
8109 if (ws->kind != TARGET_WAITKIND_VFORKED)
8110 return 0;
8111
8112 c->forked_inferior_pid = ws->value.related_pid;
8113 return 1;
ce78b96d
JB
8114}
8115
4a64f543
MS
8116/* Implement the "print_it" breakpoint_ops method for vfork
8117 catchpoints. */
ce78b96d
JB
8118
8119static enum print_stop_action
348d480f 8120print_it_catch_vfork (bpstat bs)
ce78b96d 8121{
36dfb11c 8122 struct ui_out *uiout = current_uiout;
348d480f 8123 struct breakpoint *b = bs->breakpoint_at;
e29a4733
PA
8124 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
8125
ce78b96d 8126 annotate_catchpoint (b->number);
36dfb11c
TT
8127 if (b->disposition == disp_del)
8128 ui_out_text (uiout, "\nTemporary catchpoint ");
8129 else
8130 ui_out_text (uiout, "\nCatchpoint ");
8131 if (ui_out_is_mi_like_p (uiout))
8132 {
8133 ui_out_field_string (uiout, "reason",
8134 async_reason_lookup (EXEC_ASYNC_VFORK));
8135 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8136 }
8137 ui_out_field_int (uiout, "bkptno", b->number);
8138 ui_out_text (uiout, " (vforked process ");
8139 ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
8140 ui_out_text (uiout, "), ");
ce78b96d
JB
8141 return PRINT_SRC_AND_LOC;
8142}
8143
4a64f543
MS
8144/* Implement the "print_one" breakpoint_ops method for vfork
8145 catchpoints. */
ce78b96d
JB
8146
8147static void
a6d9a66e 8148print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
ce78b96d 8149{
e29a4733 8150 struct fork_catchpoint *c = (struct fork_catchpoint *) b;
79a45b7d 8151 struct value_print_options opts;
79a45e25 8152 struct ui_out *uiout = current_uiout;
79a45b7d
TT
8153
8154 get_user_print_options (&opts);
4a64f543
MS
8155 /* Field 4, the address, is omitted (which makes the columns not
8156 line up too nicely with the headers, but the effect is relatively
8157 readable). */
79a45b7d 8158 if (opts.addressprint)
ce78b96d
JB
8159 ui_out_field_skip (uiout, "addr");
8160 annotate_field (5);
8161 ui_out_text (uiout, "vfork");
e29a4733 8162 if (!ptid_equal (c->forked_inferior_pid, null_ptid))
ce78b96d
JB
8163 {
8164 ui_out_text (uiout, ", process ");
8165 ui_out_field_int (uiout, "what",
e29a4733 8166 ptid_get_pid (c->forked_inferior_pid));
ce78b96d
JB
8167 ui_out_spaces (uiout, 1);
8168 }
8ac3646f
TT
8169
8170 if (ui_out_is_mi_like_p (uiout))
8171 ui_out_field_string (uiout, "catch-type", "vfork");
ce78b96d
JB
8172}
8173
8174/* Implement the "print_mention" breakpoint_ops method for vfork
8175 catchpoints. */
8176
8177static void
8178print_mention_catch_vfork (struct breakpoint *b)
8179{
8180 printf_filtered (_("Catchpoint %d (vfork)"), b->number);
8181}
8182
6149aea9
PA
8183/* Implement the "print_recreate" breakpoint_ops method for vfork
8184 catchpoints. */
8185
8186static void
8187print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
8188{
8189 fprintf_unfiltered (fp, "catch vfork");
d9b3f62e 8190 print_recreate_thread (b, fp);
6149aea9
PA
8191}
8192
ce78b96d
JB
8193/* The breakpoint_ops structure to be used in vfork catchpoints. */
8194
2060206e 8195static struct breakpoint_ops catch_vfork_breakpoint_ops;
ce78b96d 8196
edcc5120
TT
8197/* An instance of this type is used to represent an solib catchpoint.
8198 It includes a "struct breakpoint" as a kind of base class; users
8199 downcast to "struct breakpoint *" when needed. A breakpoint is
8200 really of this type iff its ops pointer points to
8201 CATCH_SOLIB_BREAKPOINT_OPS. */
8202
8203struct solib_catchpoint
8204{
8205 /* The base class. */
8206 struct breakpoint base;
8207
8208 /* True for "catch load", false for "catch unload". */
8209 unsigned char is_load;
8210
8211 /* Regular expression to match, if any. COMPILED is only valid when
8212 REGEX is non-NULL. */
8213 char *regex;
8214 regex_t compiled;
8215};
8216
8217static void
8218dtor_catch_solib (struct breakpoint *b)
8219{
8220 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8221
8222 if (self->regex)
8223 regfree (&self->compiled);
8224 xfree (self->regex);
8225
8226 base_breakpoint_ops.dtor (b);
8227}
8228
8229static int
8230insert_catch_solib (struct bp_location *ignore)
8231{
8232 return 0;
8233}
8234
8235static int
8236remove_catch_solib (struct bp_location *ignore)
8237{
8238 return 0;
8239}
8240
8241static int
8242breakpoint_hit_catch_solib (const struct bp_location *bl,
8243 struct address_space *aspace,
8244 CORE_ADDR bp_addr,
8245 const struct target_waitstatus *ws)
8246{
8247 struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
8248 struct breakpoint *other;
8249
8250 if (ws->kind == TARGET_WAITKIND_LOADED)
8251 return 1;
8252
8253 ALL_BREAKPOINTS (other)
8254 {
8255 struct bp_location *other_bl;
8256
8257 if (other == bl->owner)
8258 continue;
8259
8260 if (other->type != bp_shlib_event)
8261 continue;
8262
8263 if (self->base.pspace != NULL && other->pspace != self->base.pspace)
8264 continue;
8265
8266 for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
8267 {
8268 if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
8269 return 1;
8270 }
8271 }
8272
8273 return 0;
8274}
8275
8276static void
8277check_status_catch_solib (struct bpstats *bs)
8278{
8279 struct solib_catchpoint *self
8280 = (struct solib_catchpoint *) bs->breakpoint_at;
8281 int ix;
8282
8283 if (self->is_load)
8284 {
8285 struct so_list *iter;
8286
8287 for (ix = 0;
8288 VEC_iterate (so_list_ptr, current_program_space->added_solibs,
8289 ix, iter);
8290 ++ix)
8291 {
8292 if (!self->regex
8293 || regexec (&self->compiled, iter->so_name, 0, NULL, 0) == 0)
8294 return;
8295 }
8296 }
8297 else
8298 {
8299 char *iter;
8300
8301 for (ix = 0;
8302 VEC_iterate (char_ptr, current_program_space->deleted_solibs,
8303 ix, iter);
8304 ++ix)
8305 {
8306 if (!self->regex
8307 || regexec (&self->compiled, iter, 0, NULL, 0) == 0)
8308 return;
8309 }
8310 }
8311
8312 bs->stop = 0;
8313 bs->print_it = print_it_noop;
8314}
8315
8316static enum print_stop_action
8317print_it_catch_solib (bpstat bs)
8318{
8319 struct breakpoint *b = bs->breakpoint_at;
8320 struct ui_out *uiout = current_uiout;
8321
8322 annotate_catchpoint (b->number);
8323 if (b->disposition == disp_del)
8324 ui_out_text (uiout, "\nTemporary catchpoint ");
8325 else
8326 ui_out_text (uiout, "\nCatchpoint ");
8327 ui_out_field_int (uiout, "bkptno", b->number);
8328 ui_out_text (uiout, "\n");
8329 if (ui_out_is_mi_like_p (uiout))
8330 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8331 print_solib_event (1);
8332 return PRINT_SRC_AND_LOC;
8333}
8334
8335static void
8336print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
8337{
8338 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8339 struct value_print_options opts;
8340 struct ui_out *uiout = current_uiout;
8341 char *msg;
8342
8343 get_user_print_options (&opts);
8344 /* Field 4, the address, is omitted (which makes the columns not
8345 line up too nicely with the headers, but the effect is relatively
8346 readable). */
8347 if (opts.addressprint)
8348 {
8349 annotate_field (4);
8350 ui_out_field_skip (uiout, "addr");
8351 }
8352
8353 annotate_field (5);
8354 if (self->is_load)
8355 {
8356 if (self->regex)
8357 msg = xstrprintf (_("load of library matching %s"), self->regex);
8358 else
8359 msg = xstrdup (_("load of library"));
8360 }
8361 else
8362 {
8363 if (self->regex)
8364 msg = xstrprintf (_("unload of library matching %s"), self->regex);
8365 else
8366 msg = xstrdup (_("unload of library"));
8367 }
8368 ui_out_field_string (uiout, "what", msg);
8369 xfree (msg);
8ac3646f
TT
8370
8371 if (ui_out_is_mi_like_p (uiout))
8372 ui_out_field_string (uiout, "catch-type",
8373 self->is_load ? "load" : "unload");
edcc5120
TT
8374}
8375
8376static void
8377print_mention_catch_solib (struct breakpoint *b)
8378{
8379 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8380
8381 printf_filtered (_("Catchpoint %d (%s)"), b->number,
8382 self->is_load ? "load" : "unload");
8383}
8384
8385static void
8386print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
8387{
8388 struct solib_catchpoint *self = (struct solib_catchpoint *) b;
8389
8390 fprintf_unfiltered (fp, "%s %s",
8391 b->disposition == disp_del ? "tcatch" : "catch",
8392 self->is_load ? "load" : "unload");
8393 if (self->regex)
8394 fprintf_unfiltered (fp, " %s", self->regex);
8395 fprintf_unfiltered (fp, "\n");
8396}
8397
8398static struct breakpoint_ops catch_solib_breakpoint_ops;
8399
91985142
MG
8400/* Shared helper function (MI and CLI) for creating and installing
8401 a shared object event catchpoint. If IS_LOAD is non-zero then
8402 the events to be caught are load events, otherwise they are
8403 unload events. If IS_TEMP is non-zero the catchpoint is a
8404 temporary one. If ENABLED is non-zero the catchpoint is
8405 created in an enabled state. */
edcc5120 8406
91985142
MG
8407void
8408add_solib_catchpoint (char *arg, int is_load, int is_temp, int enabled)
edcc5120
TT
8409{
8410 struct solib_catchpoint *c;
8411 struct gdbarch *gdbarch = get_current_arch ();
edcc5120
TT
8412 struct cleanup *cleanup;
8413
edcc5120
TT
8414 if (!arg)
8415 arg = "";
8416 arg = skip_spaces (arg);
8417
8418 c = XCNEW (struct solib_catchpoint);
8419 cleanup = make_cleanup (xfree, c);
8420
8421 if (*arg != '\0')
8422 {
8423 int errcode;
8424
8425 errcode = regcomp (&c->compiled, arg, REG_NOSUB);
8426 if (errcode != 0)
8427 {
8428 char *err = get_regcomp_error (errcode, &c->compiled);
8429
8430 make_cleanup (xfree, err);
8431 error (_("Invalid regexp (%s): %s"), err, arg);
8432 }
8433 c->regex = xstrdup (arg);
8434 }
8435
8436 c->is_load = is_load;
91985142 8437 init_catchpoint (&c->base, gdbarch, is_temp, NULL,
edcc5120
TT
8438 &catch_solib_breakpoint_ops);
8439
91985142
MG
8440 c->base.enable_state = enabled ? bp_enabled : bp_disabled;
8441
edcc5120
TT
8442 discard_cleanups (cleanup);
8443 install_breakpoint (0, &c->base, 1);
8444}
8445
91985142
MG
8446/* A helper function that does all the work for "catch load" and
8447 "catch unload". */
8448
8449static void
8450catch_load_or_unload (char *arg, int from_tty, int is_load,
8451 struct cmd_list_element *command)
8452{
8453 int tempflag;
8454 const int enabled = 1;
8455
8456 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
8457
8458 add_solib_catchpoint (arg, is_load, tempflag, enabled);
8459}
8460
edcc5120
TT
8461static void
8462catch_load_command_1 (char *arg, int from_tty,
8463 struct cmd_list_element *command)
8464{
8465 catch_load_or_unload (arg, from_tty, 1, command);
8466}
8467
8468static void
8469catch_unload_command_1 (char *arg, int from_tty,
8470 struct cmd_list_element *command)
8471{
8472 catch_load_or_unload (arg, from_tty, 0, command);
8473}
8474
346774a9
PA
8475/* Initialize a new breakpoint of the bp_catchpoint kind. If TEMPFLAG
8476 is non-zero, then make the breakpoint temporary. If COND_STRING is
8477 not NULL, then store it in the breakpoint. OPS, if not NULL, is
8478 the breakpoint_ops structure associated to the catchpoint. */
ce78b96d 8479
ab04a2af 8480void
346774a9
PA
8481init_catchpoint (struct breakpoint *b,
8482 struct gdbarch *gdbarch, int tempflag,
8483 char *cond_string,
c0a91b2b 8484 const struct breakpoint_ops *ops)
c906108c 8485{
c5aa993b 8486 struct symtab_and_line sal;
346774a9 8487
fe39c653 8488 init_sal (&sal);
6c95b8df 8489 sal.pspace = current_program_space;
c5aa993b 8490
28010a5d 8491 init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
ce78b96d 8492
1b36a34b 8493 b->cond_string = (cond_string == NULL) ? NULL : xstrdup (cond_string);
b5de0fa7 8494 b->disposition = tempflag ? disp_del : disp_donttouch;
346774a9
PA
8495}
8496
28010a5d 8497void
3ea46bff 8498install_breakpoint (int internal, struct breakpoint *b, int update_gll)
c56053d2
PA
8499{
8500 add_to_breakpoint_chain (b);
3a5c3e22 8501 set_breakpoint_number (internal, b);
558a9d82
YQ
8502 if (is_tracepoint (b))
8503 set_tracepoint_count (breakpoint_count);
3a5c3e22
PA
8504 if (!internal)
8505 mention (b);
c56053d2 8506 observer_notify_breakpoint_created (b);
3ea46bff
YQ
8507
8508 if (update_gll)
44702360 8509 update_global_location_list (UGLL_MAY_INSERT);
c56053d2
PA
8510}
8511
9b70b993 8512static void
a6d9a66e
UW
8513create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
8514 int tempflag, char *cond_string,
c0a91b2b 8515 const struct breakpoint_ops *ops)
c906108c 8516{
e29a4733 8517 struct fork_catchpoint *c = XNEW (struct fork_catchpoint);
ce78b96d 8518
e29a4733
PA
8519 init_catchpoint (&c->base, gdbarch, tempflag, cond_string, ops);
8520
8521 c->forked_inferior_pid = null_ptid;
8522
3ea46bff 8523 install_breakpoint (0, &c->base, 1);
c906108c
SS
8524}
8525
fe798b75
JB
8526/* Exec catchpoints. */
8527
b4d90040
PA
8528/* An instance of this type is used to represent an exec catchpoint.
8529 It includes a "struct breakpoint" as a kind of base class; users
8530 downcast to "struct breakpoint *" when needed. A breakpoint is
8531 really of this type iff its ops pointer points to
8532 CATCH_EXEC_BREAKPOINT_OPS. */
8533
8534struct exec_catchpoint
8535{
8536 /* The base class. */
8537 struct breakpoint base;
8538
8539 /* Filename of a program whose exec triggered this catchpoint.
8540 This field is only valid immediately after this catchpoint has
8541 triggered. */
8542 char *exec_pathname;
8543};
8544
8545/* Implement the "dtor" breakpoint_ops method for exec
8546 catchpoints. */
8547
8548static void
8549dtor_catch_exec (struct breakpoint *b)
8550{
8551 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8552
8553 xfree (c->exec_pathname);
348d480f 8554
2060206e 8555 base_breakpoint_ops.dtor (b);
b4d90040
PA
8556}
8557
77b06cd7
TJB
8558static int
8559insert_catch_exec (struct bp_location *bl)
c906108c 8560{
dfd4cc63 8561 return target_insert_exec_catchpoint (ptid_get_pid (inferior_ptid));
fe798b75 8562}
c906108c 8563
fe798b75 8564static int
77b06cd7 8565remove_catch_exec (struct bp_location *bl)
fe798b75 8566{
dfd4cc63 8567 return target_remove_exec_catchpoint (ptid_get_pid (inferior_ptid));
fe798b75 8568}
c906108c 8569
fe798b75 8570static int
f1310107 8571breakpoint_hit_catch_exec (const struct bp_location *bl,
09ac7c10
TT
8572 struct address_space *aspace, CORE_ADDR bp_addr,
8573 const struct target_waitstatus *ws)
fe798b75 8574{
b4d90040
PA
8575 struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
8576
f90263c1
TT
8577 if (ws->kind != TARGET_WAITKIND_EXECD)
8578 return 0;
8579
8580 c->exec_pathname = xstrdup (ws->value.execd_pathname);
8581 return 1;
fe798b75 8582}
c906108c 8583
fe798b75 8584static enum print_stop_action
348d480f 8585print_it_catch_exec (bpstat bs)
fe798b75 8586{
36dfb11c 8587 struct ui_out *uiout = current_uiout;
348d480f 8588 struct breakpoint *b = bs->breakpoint_at;
b4d90040
PA
8589 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
8590
fe798b75 8591 annotate_catchpoint (b->number);
36dfb11c
TT
8592 if (b->disposition == disp_del)
8593 ui_out_text (uiout, "\nTemporary catchpoint ");
8594 else
8595 ui_out_text (uiout, "\nCatchpoint ");
8596 if (ui_out_is_mi_like_p (uiout))
8597 {
8598 ui_out_field_string (uiout, "reason",
8599 async_reason_lookup (EXEC_ASYNC_EXEC));
8600 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
8601 }
8602 ui_out_field_int (uiout, "bkptno", b->number);
8603 ui_out_text (uiout, " (exec'd ");
8604 ui_out_field_string (uiout, "new-exec", c->exec_pathname);
8605 ui_out_text (uiout, "), ");
8606
fe798b75 8607 return PRINT_SRC_AND_LOC;
c906108c
SS
8608}
8609
fe798b75 8610static void
a6d9a66e 8611print_one_catch_exec (struct breakpoint *b, struct bp_location **last_loc)
fe798b75 8612{
b4d90040 8613 struct exec_catchpoint *c = (struct exec_catchpoint *) b;
fe798b75 8614 struct value_print_options opts;
79a45e25 8615 struct ui_out *uiout = current_uiout;
fe798b75
JB
8616
8617 get_user_print_options (&opts);
8618
8619 /* Field 4, the address, is omitted (which makes the columns
8620 not line up too nicely with the headers, but the effect
8621 is relatively readable). */
8622 if (opts.addressprint)
8623 ui_out_field_skip (uiout, "addr");
8624 annotate_field (5);
8625 ui_out_text (uiout, "exec");
b4d90040 8626 if (c->exec_pathname != NULL)
fe798b75
JB
8627 {
8628 ui_out_text (uiout, ", program \"");
b4d90040 8629 ui_out_field_string (uiout, "what", c->exec_pathname);
fe798b75
JB
8630 ui_out_text (uiout, "\" ");
8631 }
8ac3646f
TT
8632
8633 if (ui_out_is_mi_like_p (uiout))
8634 ui_out_field_string (uiout, "catch-type", "exec");
fe798b75
JB
8635}
8636
8637static void
8638print_mention_catch_exec (struct breakpoint *b)
8639{
8640 printf_filtered (_("Catchpoint %d (exec)"), b->number);
8641}
8642
6149aea9
PA
8643/* Implement the "print_recreate" breakpoint_ops method for exec
8644 catchpoints. */
8645
8646static void
8647print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
8648{
8649 fprintf_unfiltered (fp, "catch exec");
d9b3f62e 8650 print_recreate_thread (b, fp);
6149aea9
PA
8651}
8652
2060206e 8653static struct breakpoint_ops catch_exec_breakpoint_ops;
fe798b75 8654
c906108c 8655static int
fba45db2 8656hw_breakpoint_used_count (void)
c906108c 8657{
c906108c 8658 int i = 0;
f1310107
TJB
8659 struct breakpoint *b;
8660 struct bp_location *bl;
c906108c
SS
8661
8662 ALL_BREAKPOINTS (b)
c5aa993b 8663 {
d6b74ac4 8664 if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
f1310107
TJB
8665 for (bl = b->loc; bl; bl = bl->next)
8666 {
8667 /* Special types of hardware breakpoints may use more than
8668 one register. */
348d480f 8669 i += b->ops->resources_needed (bl);
f1310107 8670 }
c5aa993b 8671 }
c906108c
SS
8672
8673 return i;
8674}
8675
a1398e0c
PA
8676/* Returns the resources B would use if it were a hardware
8677 watchpoint. */
8678
c906108c 8679static int
a1398e0c 8680hw_watchpoint_use_count (struct breakpoint *b)
c906108c 8681{
c906108c 8682 int i = 0;
e09342b5 8683 struct bp_location *bl;
c906108c 8684
a1398e0c
PA
8685 if (!breakpoint_enabled (b))
8686 return 0;
8687
8688 for (bl = b->loc; bl; bl = bl->next)
8689 {
8690 /* Special types of hardware watchpoints may use more than
8691 one register. */
8692 i += b->ops->resources_needed (bl);
8693 }
8694
8695 return i;
8696}
8697
8698/* Returns the sum the used resources of all hardware watchpoints of
8699 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8700 the sum of the used resources of all hardware watchpoints of other
8701 types _not_ TYPE. */
8702
8703static int
8704hw_watchpoint_used_count_others (struct breakpoint *except,
8705 enum bptype type, int *other_type_used)
8706{
8707 int i = 0;
8708 struct breakpoint *b;
8709
c906108c
SS
8710 *other_type_used = 0;
8711 ALL_BREAKPOINTS (b)
e09342b5 8712 {
a1398e0c
PA
8713 if (b == except)
8714 continue;
e09342b5
TJB
8715 if (!breakpoint_enabled (b))
8716 continue;
8717
a1398e0c
PA
8718 if (b->type == type)
8719 i += hw_watchpoint_use_count (b);
8720 else if (is_hardware_watchpoint (b))
8721 *other_type_used = 1;
e09342b5
TJB
8722 }
8723
c906108c
SS
8724 return i;
8725}
8726
c906108c 8727void
fba45db2 8728disable_watchpoints_before_interactive_call_start (void)
c906108c 8729{
c5aa993b 8730 struct breakpoint *b;
c906108c
SS
8731
8732 ALL_BREAKPOINTS (b)
c5aa993b 8733 {
cc60f2e3 8734 if (is_watchpoint (b) && breakpoint_enabled (b))
c5aa993b 8735 {
b5de0fa7 8736 b->enable_state = bp_call_disabled;
44702360 8737 update_global_location_list (UGLL_DONT_INSERT);
c5aa993b
JM
8738 }
8739 }
c906108c
SS
8740}
8741
8742void
fba45db2 8743enable_watchpoints_after_interactive_call_stop (void)
c906108c 8744{
c5aa993b 8745 struct breakpoint *b;
c906108c
SS
8746
8747 ALL_BREAKPOINTS (b)
c5aa993b 8748 {
cc60f2e3 8749 if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
c5aa993b 8750 {
b5de0fa7 8751 b->enable_state = bp_enabled;
44702360 8752 update_global_location_list (UGLL_MAY_INSERT);
c5aa993b
JM
8753 }
8754 }
c906108c
SS
8755}
8756
8bea4e01
UW
8757void
8758disable_breakpoints_before_startup (void)
8759{
6c95b8df 8760 current_program_space->executing_startup = 1;
44702360 8761 update_global_location_list (UGLL_DONT_INSERT);
8bea4e01
UW
8762}
8763
8764void
8765enable_breakpoints_after_startup (void)
8766{
6c95b8df 8767 current_program_space->executing_startup = 0;
f8eba3c6 8768 breakpoint_re_set ();
8bea4e01
UW
8769}
8770
7c16b83e
PA
8771/* Create a new single-step breakpoint for thread THREAD, with no
8772 locations. */
c906108c 8773
7c16b83e
PA
8774static struct breakpoint *
8775new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
8776{
8777 struct breakpoint *b = XNEW (struct breakpoint);
8778
8779 init_raw_breakpoint_without_location (b, gdbarch, bp_single_step,
8780 &momentary_breakpoint_ops);
8781
8782 b->disposition = disp_donttouch;
8783 b->frame_id = null_frame_id;
8784
8785 b->thread = thread;
8786 gdb_assert (b->thread != 0);
8787
8788 add_to_breakpoint_chain (b);
8789
8790 return b;
8791}
8792
8793/* Set a momentary breakpoint of type TYPE at address specified by
8794 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8795 frame. */
c906108c
SS
8796
8797struct breakpoint *
a6d9a66e
UW
8798set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
8799 struct frame_id frame_id, enum bptype type)
c906108c 8800{
52f0bd74 8801 struct breakpoint *b;
edb3359d 8802
193facb3
JK
8803 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8804 tail-called one. */
8805 gdb_assert (!frame_id_artificial_p (frame_id));
edb3359d 8806
06edf0c0 8807 b = set_raw_breakpoint (gdbarch, sal, type, &momentary_breakpoint_ops);
b5de0fa7
EZ
8808 b->enable_state = bp_enabled;
8809 b->disposition = disp_donttouch;
818dd999 8810 b->frame_id = frame_id;
c906108c 8811
4a64f543
MS
8812 /* If we're debugging a multi-threaded program, then we want
8813 momentary breakpoints to be active in only a single thread of
8814 control. */
39f77062
KB
8815 if (in_thread_list (inferior_ptid))
8816 b->thread = pid_to_thread_id (inferior_ptid);
c906108c 8817
44702360 8818 update_global_location_list_nothrow (UGLL_MAY_INSERT);
74960c60 8819
c906108c
SS
8820 return b;
8821}
611c83ae 8822
06edf0c0 8823/* Make a momentary breakpoint based on the master breakpoint ORIG.
a1aa2221
LM
8824 The new breakpoint will have type TYPE, use OPS as its
8825 breakpoint_ops, and will set enabled to LOC_ENABLED. */
e58b0e63 8826
06edf0c0
PA
8827static struct breakpoint *
8828momentary_breakpoint_from_master (struct breakpoint *orig,
8829 enum bptype type,
a1aa2221
LM
8830 const struct breakpoint_ops *ops,
8831 int loc_enabled)
e58b0e63
PA
8832{
8833 struct breakpoint *copy;
8834
06edf0c0 8835 copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
e58b0e63 8836 copy->loc = allocate_bp_location (copy);
0e30163f 8837 set_breakpoint_location_function (copy->loc, 1);
e58b0e63 8838
a6d9a66e 8839 copy->loc->gdbarch = orig->loc->gdbarch;
e58b0e63
PA
8840 copy->loc->requested_address = orig->loc->requested_address;
8841 copy->loc->address = orig->loc->address;
8842 copy->loc->section = orig->loc->section;
6c95b8df 8843 copy->loc->pspace = orig->loc->pspace;
55aa24fb 8844 copy->loc->probe = orig->loc->probe;
f8eba3c6 8845 copy->loc->line_number = orig->loc->line_number;
2f202fde 8846 copy->loc->symtab = orig->loc->symtab;
a1aa2221 8847 copy->loc->enabled = loc_enabled;
e58b0e63
PA
8848 copy->frame_id = orig->frame_id;
8849 copy->thread = orig->thread;
6c95b8df 8850 copy->pspace = orig->pspace;
e58b0e63
PA
8851
8852 copy->enable_state = bp_enabled;
8853 copy->disposition = disp_donttouch;
8854 copy->number = internal_breakpoint_number--;
8855
44702360 8856 update_global_location_list_nothrow (UGLL_DONT_INSERT);
e58b0e63
PA
8857 return copy;
8858}
8859
06edf0c0
PA
8860/* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8861 ORIG is NULL. */
8862
8863struct breakpoint *
8864clone_momentary_breakpoint (struct breakpoint *orig)
8865{
8866 /* If there's nothing to clone, then return nothing. */
8867 if (orig == NULL)
8868 return NULL;
8869
a1aa2221 8870 return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
06edf0c0
PA
8871}
8872
611c83ae 8873struct breakpoint *
a6d9a66e
UW
8874set_momentary_breakpoint_at_pc (struct gdbarch *gdbarch, CORE_ADDR pc,
8875 enum bptype type)
611c83ae
PA
8876{
8877 struct symtab_and_line sal;
8878
8879 sal = find_pc_line (pc, 0);
8880 sal.pc = pc;
8881 sal.section = find_pc_overlay (pc);
8882 sal.explicit_pc = 1;
8883
a6d9a66e 8884 return set_momentary_breakpoint (gdbarch, sal, null_frame_id, type);
611c83ae 8885}
c906108c 8886\f
c5aa993b 8887
c906108c
SS
8888/* Tell the user we have just set a breakpoint B. */
8889
8890static void
fba45db2 8891mention (struct breakpoint *b)
c906108c 8892{
348d480f 8893 b->ops->print_mention (b);
79a45e25 8894 if (ui_out_is_mi_like_p (current_uiout))
fb40c209 8895 return;
c906108c
SS
8896 printf_filtered ("\n");
8897}
c906108c 8898\f
c5aa993b 8899
1a853c52
PA
8900static int bp_loc_is_permanent (struct bp_location *loc);
8901
0d381245 8902static struct bp_location *
39d61571 8903add_location_to_breakpoint (struct breakpoint *b,
0d381245
VP
8904 const struct symtab_and_line *sal)
8905{
8906 struct bp_location *loc, **tmp;
3742cc8b
YQ
8907 CORE_ADDR adjusted_address;
8908 struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
8909
8910 if (loc_gdbarch == NULL)
8911 loc_gdbarch = b->gdbarch;
8912
8913 /* Adjust the breakpoint's address prior to allocating a location.
8914 Once we call allocate_bp_location(), that mostly uninitialized
8915 location will be placed on the location chain. Adjustment of the
8916 breakpoint may cause target_read_memory() to be called and we do
8917 not want its scan of the location chain to find a breakpoint and
8918 location that's only been partially initialized. */
8919 adjusted_address = adjust_breakpoint_address (loc_gdbarch,
8920 sal->pc, b->type);
0d381245 8921
d30113d4 8922 /* Sort the locations by their ADDRESS. */
39d61571 8923 loc = allocate_bp_location (b);
d30113d4
JK
8924 for (tmp = &(b->loc); *tmp != NULL && (*tmp)->address <= adjusted_address;
8925 tmp = &((*tmp)->next))
0d381245 8926 ;
d30113d4 8927 loc->next = *tmp;
0d381245 8928 *tmp = loc;
3742cc8b 8929
0d381245 8930 loc->requested_address = sal->pc;
3742cc8b 8931 loc->address = adjusted_address;
6c95b8df 8932 loc->pspace = sal->pspace;
729662a5
TT
8933 loc->probe.probe = sal->probe;
8934 loc->probe.objfile = sal->objfile;
6c95b8df 8935 gdb_assert (loc->pspace != NULL);
0d381245 8936 loc->section = sal->section;
3742cc8b 8937 loc->gdbarch = loc_gdbarch;
f8eba3c6 8938 loc->line_number = sal->line;
2f202fde 8939 loc->symtab = sal->symtab;
f8eba3c6 8940
0e30163f
JK
8941 set_breakpoint_location_function (loc,
8942 sal->explicit_pc || sal->explicit_line);
1a853c52 8943
6ae88661
LM
8944 /* While by definition, permanent breakpoints are already present in the
8945 code, we don't mark the location as inserted. Normally one would expect
8946 that GDB could rely on that breakpoint instruction to stop the program,
8947 thus removing the need to insert its own breakpoint, except that executing
8948 the breakpoint instruction can kill the target instead of reporting a
8949 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8950 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8951 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8952 breakpoint be inserted normally results in QEMU knowing about the GDB
8953 breakpoint, and thus trap before the breakpoint instruction is executed.
8954 (If GDB later needs to continue execution past the permanent breakpoint,
8955 it manually increments the PC, thus avoiding executing the breakpoint
8956 instruction.) */
1a853c52 8957 if (bp_loc_is_permanent (loc))
6ae88661 8958 loc->permanent = 1;
1a853c52 8959
0d381245
VP
8960 return loc;
8961}
514f746b
AR
8962\f
8963
1cf4d951 8964/* See breakpoint.h. */
514f746b 8965
1cf4d951
PA
8966int
8967program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address)
514f746b
AR
8968{
8969 int len;
8970 CORE_ADDR addr;
1afeeb75 8971 const gdb_byte *bpoint;
514f746b 8972 gdb_byte *target_mem;
939c61fa
JK
8973 struct cleanup *cleanup;
8974 int retval = 0;
514f746b 8975
1cf4d951
PA
8976 addr = address;
8977 bpoint = gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
8978
8979 /* Software breakpoints unsupported? */
8980 if (bpoint == NULL)
8981 return 0;
8982
8983 target_mem = alloca (len);
8984
8985 /* Enable the automatic memory restoration from breakpoints while
8986 we read the memory. Otherwise we could say about our temporary
8987 breakpoints they are permanent. */
8988 cleanup = make_show_memory_breakpoints_cleanup (0);
8989
8990 if (target_read_memory (address, target_mem, len) == 0
8991 && memcmp (target_mem, bpoint, len) == 0)
8992 retval = 1;
8993
8994 do_cleanups (cleanup);
8995
8996 return retval;
8997}
8998
8999/* Return 1 if LOC is pointing to a permanent breakpoint,
9000 return 0 otherwise. */
9001
9002static int
9003bp_loc_is_permanent (struct bp_location *loc)
9004{
9005 struct cleanup *cleanup;
9006 int retval;
9007
514f746b
AR
9008 gdb_assert (loc != NULL);
9009
244558af
LM
9010 /* If we have a catchpoint or a watchpoint, just return 0. We should not
9011 attempt to read from the addresses the locations of these breakpoint types
9012 point to. program_breakpoint_here_p, below, will attempt to read
9013 memory. */
9014 if (!breakpoint_address_is_meaningful (loc->owner))
9015 return 0;
9016
6c95b8df 9017 cleanup = save_current_space_and_thread ();
6c95b8df 9018 switch_to_program_space_and_thread (loc->pspace);
939c61fa 9019
1cf4d951 9020 retval = program_breakpoint_here_p (loc->gdbarch, loc->address);
514f746b 9021
939c61fa
JK
9022 do_cleanups (cleanup);
9023
9024 return retval;
514f746b
AR
9025}
9026
e7e0cddf
SS
9027/* Build a command list for the dprintf corresponding to the current
9028 settings of the dprintf style options. */
9029
9030static void
9031update_dprintf_command_list (struct breakpoint *b)
9032{
9033 char *dprintf_args = b->extra_string;
9034 char *printf_line = NULL;
9035
9036 if (!dprintf_args)
9037 return;
9038
9039 dprintf_args = skip_spaces (dprintf_args);
9040
9041 /* Allow a comma, as it may have terminated a location, but don't
9042 insist on it. */
9043 if (*dprintf_args == ',')
9044 ++dprintf_args;
9045 dprintf_args = skip_spaces (dprintf_args);
9046
9047 if (*dprintf_args != '"')
9048 error (_("Bad format string, missing '\"'."));
9049
d3ce09f5 9050 if (strcmp (dprintf_style, dprintf_style_gdb) == 0)
e7e0cddf 9051 printf_line = xstrprintf ("printf %s", dprintf_args);
d3ce09f5 9052 else if (strcmp (dprintf_style, dprintf_style_call) == 0)
e7e0cddf
SS
9053 {
9054 if (!dprintf_function)
9055 error (_("No function supplied for dprintf call"));
9056
9057 if (dprintf_channel && strlen (dprintf_channel) > 0)
9058 printf_line = xstrprintf ("call (void) %s (%s,%s)",
9059 dprintf_function,
9060 dprintf_channel,
9061 dprintf_args);
9062 else
9063 printf_line = xstrprintf ("call (void) %s (%s)",
9064 dprintf_function,
9065 dprintf_args);
9066 }
d3ce09f5
SS
9067 else if (strcmp (dprintf_style, dprintf_style_agent) == 0)
9068 {
9069 if (target_can_run_breakpoint_commands ())
9070 printf_line = xstrprintf ("agent-printf %s", dprintf_args);
9071 else
9072 {
9073 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
9074 printf_line = xstrprintf ("printf %s", dprintf_args);
9075 }
9076 }
e7e0cddf
SS
9077 else
9078 internal_error (__FILE__, __LINE__,
9079 _("Invalid dprintf style."));
9080
f28045c2 9081 gdb_assert (printf_line != NULL);
9d6e6e84 9082 /* Manufacture a printf sequence. */
f28045c2 9083 {
8d749320 9084 struct command_line *printf_cmd_line = XNEW (struct command_line);
e7e0cddf 9085
f28045c2
YQ
9086 printf_cmd_line->control_type = simple_control;
9087 printf_cmd_line->body_count = 0;
9088 printf_cmd_line->body_list = NULL;
9d6e6e84 9089 printf_cmd_line->next = NULL;
f28045c2 9090 printf_cmd_line->line = printf_line;
e7e0cddf 9091
f28045c2
YQ
9092 breakpoint_set_commands (b, printf_cmd_line);
9093 }
e7e0cddf
SS
9094}
9095
9096/* Update all dprintf commands, making their command lists reflect
9097 current style settings. */
9098
9099static void
9100update_dprintf_commands (char *args, int from_tty,
9101 struct cmd_list_element *c)
9102{
9103 struct breakpoint *b;
9104
9105 ALL_BREAKPOINTS (b)
9106 {
9107 if (b->type == bp_dprintf)
9108 update_dprintf_command_list (b);
9109 }
9110}
c3f6f71d 9111
f00aae0f
KS
9112/* Create a breakpoint with SAL as location. Use LOCATION
9113 as a description of the location, and COND_STRING
db107f19 9114 as condition expression. */
018d34a4
VP
9115
9116static void
d9b3f62e 9117init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
f00aae0f
KS
9118 struct symtabs_and_lines sals,
9119 struct event_location *location,
f8eba3c6 9120 char *filter, char *cond_string,
e7e0cddf 9121 char *extra_string,
d9b3f62e
PA
9122 enum bptype type, enum bpdisp disposition,
9123 int thread, int task, int ignore_count,
c0a91b2b 9124 const struct breakpoint_ops *ops, int from_tty,
44f238bb
PA
9125 int enabled, int internal, unsigned flags,
9126 int display_canonical)
018d34a4 9127{
0d381245 9128 int i;
018d34a4
VP
9129
9130 if (type == bp_hardware_breakpoint)
9131 {
fbbd034e
AS
9132 int target_resources_ok;
9133
9134 i = hw_breakpoint_used_count ();
9135 target_resources_ok =
9136 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
018d34a4
VP
9137 i + 1, 0);
9138 if (target_resources_ok == 0)
9139 error (_("No hardware breakpoint support in the target."));
9140 else if (target_resources_ok < 0)
9141 error (_("Hardware breakpoints used exceeds limit."));
9142 }
9143
6c95b8df
PA
9144 gdb_assert (sals.nelts > 0);
9145
0d381245
VP
9146 for (i = 0; i < sals.nelts; ++i)
9147 {
9148 struct symtab_and_line sal = sals.sals[i];
9149 struct bp_location *loc;
9150
9151 if (from_tty)
5af949e3
UW
9152 {
9153 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
9154 if (!loc_gdbarch)
9155 loc_gdbarch = gdbarch;
9156
9157 describe_other_breakpoints (loc_gdbarch,
6c95b8df 9158 sal.pspace, sal.pc, sal.section, thread);
5af949e3 9159 }
0d381245
VP
9160
9161 if (i == 0)
9162 {
d9b3f62e 9163 init_raw_breakpoint (b, gdbarch, sal, type, ops);
0d381245 9164 b->thread = thread;
4a306c9a 9165 b->task = task;
855a6e68 9166
0d381245 9167 b->cond_string = cond_string;
e7e0cddf 9168 b->extra_string = extra_string;
0d381245 9169 b->ignore_count = ignore_count;
41447f92 9170 b->enable_state = enabled ? bp_enabled : bp_disabled;
0d381245 9171 b->disposition = disposition;
6c95b8df 9172
44f238bb
PA
9173 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9174 b->loc->inserted = 1;
9175
0fb4aa4b
PA
9176 if (type == bp_static_tracepoint)
9177 {
d9b3f62e 9178 struct tracepoint *t = (struct tracepoint *) b;
0fb4aa4b
PA
9179 struct static_tracepoint_marker marker;
9180
983af33b 9181 if (strace_marker_p (b))
0fb4aa4b
PA
9182 {
9183 /* We already know the marker exists, otherwise, we
9184 wouldn't see a sal for it. */
f00aae0f
KS
9185 const char *p = &event_location_to_string (b->location)[3];
9186 const char *endp;
0fb4aa4b 9187 char *marker_str;
0fb4aa4b 9188
f00aae0f 9189 p = skip_spaces_const (p);
0fb4aa4b 9190
f00aae0f 9191 endp = skip_to_space_const (p);
0fb4aa4b
PA
9192
9193 marker_str = savestring (p, endp - p);
d9b3f62e 9194 t->static_trace_marker_id = marker_str;
0fb4aa4b 9195
3e43a32a
MS
9196 printf_filtered (_("Probed static tracepoint "
9197 "marker \"%s\"\n"),
d9b3f62e 9198 t->static_trace_marker_id);
0fb4aa4b
PA
9199 }
9200 else if (target_static_tracepoint_marker_at (sal.pc, &marker))
9201 {
d9b3f62e 9202 t->static_trace_marker_id = xstrdup (marker.str_id);
0fb4aa4b
PA
9203 release_static_tracepoint_marker (&marker);
9204
3e43a32a
MS
9205 printf_filtered (_("Probed static tracepoint "
9206 "marker \"%s\"\n"),
d9b3f62e 9207 t->static_trace_marker_id);
0fb4aa4b
PA
9208 }
9209 else
3e43a32a
MS
9210 warning (_("Couldn't determine the static "
9211 "tracepoint marker to probe"));
0fb4aa4b
PA
9212 }
9213
0d381245
VP
9214 loc = b->loc;
9215 }
9216 else
018d34a4 9217 {
39d61571 9218 loc = add_location_to_breakpoint (b, &sal);
44f238bb
PA
9219 if ((flags & CREATE_BREAKPOINT_FLAGS_INSERTED) != 0)
9220 loc->inserted = 1;
0d381245
VP
9221 }
9222
9223 if (b->cond_string)
9224 {
bbc13ae3
KS
9225 const char *arg = b->cond_string;
9226
1bb9788d
TT
9227 loc->cond = parse_exp_1 (&arg, loc->address,
9228 block_for_pc (loc->address), 0);
0d381245 9229 if (*arg)
588ae58c 9230 error (_("Garbage '%s' follows condition"), arg);
018d34a4 9231 }
e7e0cddf
SS
9232
9233 /* Dynamic printf requires and uses additional arguments on the
9234 command line, otherwise it's an error. */
9235 if (type == bp_dprintf)
9236 {
9237 if (b->extra_string)
9238 update_dprintf_command_list (b);
9239 else
9240 error (_("Format string required"));
9241 }
9242 else if (b->extra_string)
588ae58c 9243 error (_("Garbage '%s' at end of command"), b->extra_string);
855a6e68 9244 }
018d34a4 9245
56435ebe 9246 b->display_canonical = display_canonical;
f00aae0f
KS
9247 if (location != NULL)
9248 b->location = location;
018d34a4 9249 else
a06efdd6 9250 b->location = new_address_location (b->loc->address);
f8eba3c6 9251 b->filter = filter;
d9b3f62e 9252}
018d34a4 9253
d9b3f62e
PA
9254static void
9255create_breakpoint_sal (struct gdbarch *gdbarch,
f00aae0f
KS
9256 struct symtabs_and_lines sals,
9257 struct event_location *location,
f8eba3c6 9258 char *filter, char *cond_string,
e7e0cddf 9259 char *extra_string,
d9b3f62e
PA
9260 enum bptype type, enum bpdisp disposition,
9261 int thread, int task, int ignore_count,
c0a91b2b 9262 const struct breakpoint_ops *ops, int from_tty,
44f238bb
PA
9263 int enabled, int internal, unsigned flags,
9264 int display_canonical)
d9b3f62e
PA
9265{
9266 struct breakpoint *b;
9267 struct cleanup *old_chain;
9268
9269 if (is_tracepoint_type (type))
9270 {
9271 struct tracepoint *t;
9272
9273 t = XCNEW (struct tracepoint);
9274 b = &t->base;
9275 }
9276 else
9277 b = XNEW (struct breakpoint);
9278
9279 old_chain = make_cleanup (xfree, b);
9280
9281 init_breakpoint_sal (b, gdbarch,
f00aae0f 9282 sals, location,
e7e0cddf 9283 filter, cond_string, extra_string,
d9b3f62e
PA
9284 type, disposition,
9285 thread, task, ignore_count,
9286 ops, from_tty,
44f238bb
PA
9287 enabled, internal, flags,
9288 display_canonical);
d9b3f62e
PA
9289 discard_cleanups (old_chain);
9290
3ea46bff 9291 install_breakpoint (internal, b, 0);
018d34a4
VP
9292}
9293
9294/* Add SALS.nelts breakpoints to the breakpoint table. For each
9295 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9296 value. COND_STRING, if not NULL, specified the condition to be
9297 used for all breakpoints. Essentially the only case where
9298 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9299 function. In that case, it's still not possible to specify
9300 separate conditions for different overloaded functions, so
9301 we take just a single condition string.
9302
c3f6f71d 9303 NOTE: If the function succeeds, the caller is expected to cleanup
018d34a4 9304 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
c3f6f71d
JM
9305 array contents). If the function fails (error() is called), the
9306 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4a64f543 9307 COND and SALS arrays and each of those arrays contents. */
c906108c
SS
9308
9309static void
8cdf0e15 9310create_breakpoints_sal (struct gdbarch *gdbarch,
7efd8fc2 9311 struct linespec_result *canonical,
e7e0cddf 9312 char *cond_string, char *extra_string,
8cdf0e15
VP
9313 enum bptype type, enum bpdisp disposition,
9314 int thread, int task, int ignore_count,
c0a91b2b 9315 const struct breakpoint_ops *ops, int from_tty,
44f238bb 9316 int enabled, int internal, unsigned flags)
c906108c 9317{
018d34a4 9318 int i;
f8eba3c6 9319 struct linespec_sals *lsal;
cc59ec59 9320
f8eba3c6
TT
9321 if (canonical->pre_expanded)
9322 gdb_assert (VEC_length (linespec_sals, canonical->sals) == 1);
9323
9324 for (i = 0; VEC_iterate (linespec_sals, canonical->sals, i, lsal); ++i)
c3f6f71d 9325 {
f00aae0f 9326 /* Note that 'location' can be NULL in the case of a plain
f8eba3c6 9327 'break', without arguments. */
f00aae0f
KS
9328 struct event_location *location
9329 = (canonical->location != NULL
9330 ? copy_event_location (canonical->location) : NULL);
f8eba3c6 9331 char *filter_string = lsal->canonical ? xstrdup (lsal->canonical) : NULL;
f00aae0f 9332 struct cleanup *inner = make_cleanup_delete_event_location (location);
0d381245 9333
f8eba3c6
TT
9334 make_cleanup (xfree, filter_string);
9335 create_breakpoint_sal (gdbarch, lsal->sals,
f00aae0f 9336 location,
f8eba3c6 9337 filter_string,
e7e0cddf
SS
9338 cond_string, extra_string,
9339 type, disposition,
84f4c1fe 9340 thread, task, ignore_count, ops,
44f238bb 9341 from_tty, enabled, internal, flags,
56435ebe 9342 canonical->special_display);
f8eba3c6 9343 discard_cleanups (inner);
c3f6f71d 9344 }
c3f6f71d 9345}
c906108c 9346
f00aae0f 9347/* Parse LOCATION which is assumed to be a SAL specification possibly
c3f6f71d 9348 followed by conditionals. On return, SALS contains an array of SAL
f00aae0f
KS
9349 addresses found. LOCATION points to the end of the SAL (for
9350 linespec locations).
9998af43
TJB
9351
9352 The array and the line spec strings are allocated on the heap, it is
9353 the caller's responsibility to free them. */
c906108c 9354
b9362cc7 9355static void
f00aae0f 9356parse_breakpoint_sals (const struct event_location *location,
58438ac1 9357 struct linespec_result *canonical)
c3f6f71d 9358{
f00aae0f
KS
9359 struct symtab_and_line cursal;
9360
9361 if (event_location_type (location) == LINESPEC_LOCATION)
9362 {
9363 const char *address = get_linespec_location (location);
9364
9365 if (address == NULL)
9366 {
9367 /* The last displayed codepoint, if it's valid, is our default
9368 breakpoint address. */
9369 if (last_displayed_sal_is_valid ())
9370 {
9371 struct linespec_sals lsal;
9372 struct symtab_and_line sal;
9373 CORE_ADDR pc;
9374
9375 init_sal (&sal); /* Initialize to zeroes. */
8d749320 9376 lsal.sals.sals = XNEW (struct symtab_and_line);
f00aae0f
KS
9377
9378 /* Set sal's pspace, pc, symtab, and line to the values
9379 corresponding to the last call to print_frame_info.
9380 Be sure to reinitialize LINE with NOTCURRENT == 0
9381 as the breakpoint line number is inappropriate otherwise.
9382 find_pc_line would adjust PC, re-set it back. */
9383 get_last_displayed_sal (&sal);
9384 pc = sal.pc;
9385 sal = find_pc_line (pc, 0);
9386
9387 /* "break" without arguments is equivalent to "break *PC"
9388 where PC is the last displayed codepoint's address. So
9389 make sure to set sal.explicit_pc to prevent GDB from
9390 trying to expand the list of sals to include all other
9391 instances with the same symtab and line. */
9392 sal.pc = pc;
9393 sal.explicit_pc = 1;
9394
9395 lsal.sals.sals[0] = sal;
9396 lsal.sals.nelts = 1;
9397 lsal.canonical = NULL;
9398
9399 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
9400 return;
9401 }
9402 else
9403 error (_("No default breakpoint address now."));
c906108c 9404 }
c906108c 9405 }
f00aae0f
KS
9406
9407 /* Force almost all breakpoints to be in terms of the
9408 current_source_symtab (which is decode_line_1's default).
9409 This should produce the results we want almost all of the
9410 time while leaving default_breakpoint_* alone.
9411
9412 ObjC: However, don't match an Objective-C method name which
9413 may have a '+' or '-' succeeded by a '['. */
9414 cursal = get_current_source_symtab_and_line ();
9415 if (last_displayed_sal_is_valid ())
c906108c 9416 {
f00aae0f 9417 const char *address = NULL;
cc80f267 9418
f00aae0f
KS
9419 if (event_location_type (location) == LINESPEC_LOCATION)
9420 address = get_linespec_location (location);
cc80f267 9421
f00aae0f
KS
9422 if (!cursal.symtab
9423 || (address != NULL
9424 && strchr ("+-", address[0]) != NULL
9425 && address[1] != '['))
9426 {
9427 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE,
9428 get_last_displayed_symtab (),
9429 get_last_displayed_line (),
9430 canonical, NULL, NULL);
9431 return;
9432 }
c906108c 9433 }
f00aae0f
KS
9434
9435 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE,
9436 cursal.symtab, cursal.line, canonical, NULL, NULL);
c3f6f71d 9437}
c906108c 9438
c906108c 9439
c3f6f71d 9440/* Convert each SAL into a real PC. Verify that the PC can be
4a64f543 9441 inserted as a breakpoint. If it can't throw an error. */
c906108c 9442
b9362cc7 9443static void
23e7acfb 9444breakpoint_sals_to_pc (struct symtabs_and_lines *sals)
c3f6f71d
JM
9445{
9446 int i;
cc59ec59 9447
c3f6f71d 9448 for (i = 0; i < sals->nelts; i++)
ee53e872 9449 resolve_sal_pc (&sals->sals[i]);
c3f6f71d
JM
9450}
9451
7a697b8d
SS
9452/* Fast tracepoints may have restrictions on valid locations. For
9453 instance, a fast tracepoint using a jump instead of a trap will
9454 likely have to overwrite more bytes than a trap would, and so can
9455 only be placed where the instruction is longer than the jump, or a
9456 multi-instruction sequence does not have a jump into the middle of
9457 it, etc. */
9458
9459static void
9460check_fast_tracepoint_sals (struct gdbarch *gdbarch,
9461 struct symtabs_and_lines *sals)
9462{
9463 int i, rslt;
9464 struct symtab_and_line *sal;
9465 char *msg;
9466 struct cleanup *old_chain;
9467
9468 for (i = 0; i < sals->nelts; i++)
9469 {
f8eba3c6
TT
9470 struct gdbarch *sarch;
9471
7a697b8d
SS
9472 sal = &sals->sals[i];
9473
f8eba3c6
TT
9474 sarch = get_sal_arch (*sal);
9475 /* We fall back to GDBARCH if there is no architecture
9476 associated with SAL. */
9477 if (sarch == NULL)
9478 sarch = gdbarch;
6b940e6a 9479 rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal->pc, &msg);
7a697b8d
SS
9480 old_chain = make_cleanup (xfree, msg);
9481
9482 if (!rslt)
9483 error (_("May not have a fast tracepoint at 0x%s%s"),
f8eba3c6 9484 paddress (sarch, sal->pc), (msg ? msg : ""));
7a697b8d
SS
9485
9486 do_cleanups (old_chain);
9487 }
9488}
9489
af4908ba
KS
9490/* Issue an invalid thread ID error. */
9491
9492static void ATTRIBUTE_NORETURN
9493invalid_thread_id_error (int id)
9494{
9495 error (_("Unknown thread %d."), id);
9496}
9497
018d34a4
VP
9498/* Given TOK, a string specification of condition and thread, as
9499 accepted by the 'break' command, extract the condition
9500 string and thread number and set *COND_STRING and *THREAD.
4a64f543 9501 PC identifies the context at which the condition should be parsed.
018d34a4
VP
9502 If no condition is found, *COND_STRING is set to NULL.
9503 If no thread is found, *THREAD is set to -1. */
d634f2de
JB
9504
9505static void
bbc13ae3 9506find_condition_and_thread (const char *tok, CORE_ADDR pc,
e7e0cddf
SS
9507 char **cond_string, int *thread, int *task,
9508 char **rest)
018d34a4
VP
9509{
9510 *cond_string = NULL;
9511 *thread = -1;
ed1d1739
KS
9512 *task = 0;
9513 *rest = NULL;
9514
018d34a4
VP
9515 while (tok && *tok)
9516 {
bbc13ae3 9517 const char *end_tok;
018d34a4 9518 int toklen;
bbc13ae3
KS
9519 const char *cond_start = NULL;
9520 const char *cond_end = NULL;
cc59ec59 9521
bbc13ae3 9522 tok = skip_spaces_const (tok);
e7e0cddf
SS
9523
9524 if ((*tok == '"' || *tok == ',') && rest)
9525 {
9526 *rest = savestring (tok, strlen (tok));
9527 return;
9528 }
9529
bbc13ae3 9530 end_tok = skip_to_space_const (tok);
d634f2de 9531
018d34a4 9532 toklen = end_tok - tok;
d634f2de 9533
018d34a4
VP
9534 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
9535 {
f7545552
TT
9536 struct expression *expr;
9537
018d34a4 9538 tok = cond_start = end_tok + 1;
1bb9788d 9539 expr = parse_exp_1 (&tok, pc, block_for_pc (pc), 0);
f7545552 9540 xfree (expr);
018d34a4 9541 cond_end = tok;
d634f2de 9542 *cond_string = savestring (cond_start, cond_end - cond_start);
018d34a4
VP
9543 }
9544 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
9545 {
9546 char *tmptok;
d634f2de 9547
018d34a4 9548 tok = end_tok + 1;
bbc13ae3 9549 *thread = strtol (tok, &tmptok, 0);
018d34a4
VP
9550 if (tok == tmptok)
9551 error (_("Junk after thread keyword."));
9552 if (!valid_thread_id (*thread))
af4908ba 9553 invalid_thread_id_error (*thread);
bbc13ae3 9554 tok = tmptok;
018d34a4 9555 }
4a306c9a
JB
9556 else if (toklen >= 1 && strncmp (tok, "task", toklen) == 0)
9557 {
9558 char *tmptok;
9559
9560 tok = end_tok + 1;
bbc13ae3 9561 *task = strtol (tok, &tmptok, 0);
4a306c9a
JB
9562 if (tok == tmptok)
9563 error (_("Junk after task keyword."));
9564 if (!valid_task_id (*task))
b6199126 9565 error (_("Unknown task %d."), *task);
bbc13ae3 9566 tok = tmptok;
4a306c9a 9567 }
e7e0cddf
SS
9568 else if (rest)
9569 {
9570 *rest = savestring (tok, strlen (tok));
ccab2054 9571 return;
e7e0cddf 9572 }
018d34a4
VP
9573 else
9574 error (_("Junk at end of arguments."));
9575 }
9576}
9577
0fb4aa4b
PA
9578/* Decode a static tracepoint marker spec. */
9579
9580static struct symtabs_and_lines
f00aae0f 9581decode_static_tracepoint_spec (const char **arg_p)
0fb4aa4b
PA
9582{
9583 VEC(static_tracepoint_marker_p) *markers = NULL;
9584 struct symtabs_and_lines sals;
0fb4aa4b 9585 struct cleanup *old_chain;
f00aae0f
KS
9586 const char *p = &(*arg_p)[3];
9587 const char *endp;
0fb4aa4b
PA
9588 char *marker_str;
9589 int i;
9590
f00aae0f 9591 p = skip_spaces_const (p);
0fb4aa4b 9592
f00aae0f 9593 endp = skip_to_space_const (p);
0fb4aa4b
PA
9594
9595 marker_str = savestring (p, endp - p);
9596 old_chain = make_cleanup (xfree, marker_str);
9597
9598 markers = target_static_tracepoint_markers_by_strid (marker_str);
9599 if (VEC_empty(static_tracepoint_marker_p, markers))
9600 error (_("No known static tracepoint marker named %s"), marker_str);
9601
9602 sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
8d749320 9603 sals.sals = XNEWVEC (struct symtab_and_line, sals.nelts);
0fb4aa4b
PA
9604
9605 for (i = 0; i < sals.nelts; i++)
9606 {
9607 struct static_tracepoint_marker *marker;
9608
9609 marker = VEC_index (static_tracepoint_marker_p, markers, i);
9610
9611 init_sal (&sals.sals[i]);
9612
9613 sals.sals[i] = find_pc_line (marker->address, 0);
9614 sals.sals[i].pc = marker->address;
9615
9616 release_static_tracepoint_marker (marker);
9617 }
9618
9619 do_cleanups (old_chain);
9620
9621 *arg_p = endp;
9622 return sals;
9623}
9624
f00aae0f 9625/* See breakpoint.h. */
0101ce28 9626
8cdf0e15
VP
9627int
9628create_breakpoint (struct gdbarch *gdbarch,
f00aae0f 9629 const struct event_location *location, char *cond_string,
e7e0cddf 9630 int thread, char *extra_string,
f00aae0f 9631 int parse_extra,
0fb4aa4b 9632 int tempflag, enum bptype type_wanted,
8cdf0e15
VP
9633 int ignore_count,
9634 enum auto_boolean pending_break_support,
c0a91b2b 9635 const struct breakpoint_ops *ops,
44f238bb
PA
9636 int from_tty, int enabled, int internal,
9637 unsigned flags)
c3f6f71d 9638{
7efd8fc2 9639 struct linespec_result canonical;
c3f6f71d 9640 struct cleanup *old_chain;
80c99de1 9641 struct cleanup *bkpt_chain = NULL;
0101ce28 9642 int pending = 0;
4a306c9a 9643 int task = 0;
86b17b60 9644 int prev_bkpt_count = breakpoint_count;
c3f6f71d 9645
348d480f
PA
9646 gdb_assert (ops != NULL);
9647
f00aae0f
KS
9648 /* If extra_string isn't useful, set it to NULL. */
9649 if (extra_string != NULL && *extra_string == '\0')
9650 extra_string = NULL;
9651
7efd8fc2 9652 init_linespec_result (&canonical);
c3f6f71d 9653
492d29ea 9654 TRY
b78a6381 9655 {
f00aae0f 9656 ops->create_sals_from_location (location, &canonical, type_wanted);
b78a6381 9657 }
492d29ea 9658 CATCH (e, RETURN_MASK_ERROR)
0101ce28 9659 {
492d29ea
PA
9660 /* If caller is interested in rc value from parse, set
9661 value. */
9662 if (e.error == NOT_FOUND_ERROR)
0101ce28 9663 {
05ff989b
AC
9664 /* If pending breakpoint support is turned off, throw
9665 error. */
fa8d40ab
JJ
9666
9667 if (pending_break_support == AUTO_BOOLEAN_FALSE)
723a2275
VP
9668 throw_exception (e);
9669
9670 exception_print (gdb_stderr, e);
fa8d40ab 9671
05ff989b
AC
9672 /* If pending breakpoint support is auto query and the user
9673 selects no, then simply return the error code. */
059fb39f 9674 if (pending_break_support == AUTO_BOOLEAN_AUTO
bfccc43c
YQ
9675 && !nquery (_("Make %s pending on future shared library load? "),
9676 bptype_string (type_wanted)))
fd9b8c24 9677 return 0;
fa8d40ab 9678
05ff989b
AC
9679 /* At this point, either the user was queried about setting
9680 a pending breakpoint and selected yes, or pending
9681 breakpoint behavior is on and thus a pending breakpoint
9682 is defaulted on behalf of the user. */
f00aae0f 9683 pending = 1;
0101ce28 9684 }
492d29ea
PA
9685 else
9686 throw_exception (e);
0101ce28 9687 }
492d29ea
PA
9688 END_CATCH
9689
f00aae0f 9690 if (!pending && VEC_empty (linespec_sals, canonical.sals))
492d29ea 9691 return 0;
c3f6f71d 9692
4a64f543 9693 /* Create a chain of things that always need to be cleaned up. */
f8eba3c6 9694 old_chain = make_cleanup_destroy_linespec_result (&canonical);
c3f6f71d 9695
c3f6f71d
JM
9696 /* ----------------------------- SNIP -----------------------------
9697 Anything added to the cleanup chain beyond this point is assumed
9698 to be part of a breakpoint. If the breakpoint create succeeds
80c99de1
PA
9699 then the memory is not reclaimed. */
9700 bkpt_chain = make_cleanup (null_cleanup, 0);
c3f6f71d 9701
c3f6f71d
JM
9702 /* Resolve all line numbers to PC's and verify that the addresses
9703 are ok for the target. */
0101ce28 9704 if (!pending)
f8eba3c6
TT
9705 {
9706 int ix;
9707 struct linespec_sals *iter;
9708
9709 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9710 breakpoint_sals_to_pc (&iter->sals);
9711 }
c3f6f71d 9712
7a697b8d 9713 /* Fast tracepoints may have additional restrictions on location. */
bfccc43c 9714 if (!pending && type_wanted == bp_fast_tracepoint)
f8eba3c6
TT
9715 {
9716 int ix;
9717 struct linespec_sals *iter;
9718
9719 for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
9720 check_fast_tracepoint_sals (gdbarch, &iter->sals);
9721 }
7a697b8d 9722
c3f6f71d
JM
9723 /* Verify that condition can be parsed, before setting any
9724 breakpoints. Allocate a separate condition expression for each
4a64f543 9725 breakpoint. */
0101ce28 9726 if (!pending)
c3f6f71d 9727 {
f00aae0f 9728 if (parse_extra)
72b2ff0e 9729 {
0878d0fa 9730 char *rest;
52d361e1
YQ
9731 struct linespec_sals *lsal;
9732
9733 lsal = VEC_index (linespec_sals, canonical.sals, 0);
9734
0878d0fa
YQ
9735 /* Here we only parse 'arg' to separate condition
9736 from thread number, so parsing in context of first
9737 sal is OK. When setting the breakpoint we'll
9738 re-parse it in context of each sal. */
9739
f00aae0f
KS
9740 find_condition_and_thread (extra_string, lsal->sals.sals[0].pc,
9741 &cond_string, &thread, &task, &rest);
0878d0fa
YQ
9742 if (cond_string)
9743 make_cleanup (xfree, cond_string);
9744 if (rest)
9745 make_cleanup (xfree, rest);
9746 if (rest)
9747 extra_string = rest;
f00aae0f
KS
9748 else
9749 extra_string = NULL;
72b2ff0e 9750 }
2f069f6f 9751 else
72b2ff0e 9752 {
f00aae0f
KS
9753 if (type_wanted != bp_dprintf
9754 && extra_string != NULL && *extra_string != '\0')
9755 error (_("Garbage '%s' at end of location"), extra_string);
0878d0fa
YQ
9756
9757 /* Create a private copy of condition string. */
9758 if (cond_string)
9759 {
9760 cond_string = xstrdup (cond_string);
9761 make_cleanup (xfree, cond_string);
9762 }
9763 /* Create a private copy of any extra string. */
9764 if (extra_string)
9765 {
9766 extra_string = xstrdup (extra_string);
9767 make_cleanup (xfree, extra_string);
9768 }
72b2ff0e 9769 }
0fb4aa4b 9770
52d361e1 9771 ops->create_breakpoints_sal (gdbarch, &canonical,
e7e0cddf 9772 cond_string, extra_string, type_wanted,
d9b3f62e
PA
9773 tempflag ? disp_del : disp_donttouch,
9774 thread, task, ignore_count, ops,
44f238bb 9775 from_tty, enabled, internal, flags);
c906108c 9776 }
0101ce28
JJ
9777 else
9778 {
0101ce28
JJ
9779 struct breakpoint *b;
9780
bfccc43c
YQ
9781 if (is_tracepoint_type (type_wanted))
9782 {
9783 struct tracepoint *t;
9784
9785 t = XCNEW (struct tracepoint);
9786 b = &t->base;
9787 }
9788 else
9789 b = XNEW (struct breakpoint);
9790
9791 init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops);
f00aae0f 9792 b->location = copy_event_location (location);
bfccc43c 9793
f00aae0f
KS
9794 if (parse_extra)
9795 b->cond_string = NULL;
e12c7713
MK
9796 else
9797 {
9798 /* Create a private copy of condition string. */
9799 if (cond_string)
9800 {
9801 cond_string = xstrdup (cond_string);
9802 make_cleanup (xfree, cond_string);
9803 }
9804 b->cond_string = cond_string;
15630549 9805 b->thread = thread;
e12c7713 9806 }
f00aae0f
KS
9807
9808 /* Create a private copy of any extra string. */
9809 if (extra_string != NULL)
9810 {
9811 extra_string = xstrdup (extra_string);
9812 make_cleanup (xfree, extra_string);
9813 }
9814 b->extra_string = extra_string;
0101ce28 9815 b->ignore_count = ignore_count;
0101ce28 9816 b->disposition = tempflag ? disp_del : disp_donttouch;
0d381245 9817 b->condition_not_parsed = 1;
41447f92 9818 b->enable_state = enabled ? bp_enabled : bp_disabled;
cc72b2a2
KP
9819 if ((type_wanted != bp_breakpoint
9820 && type_wanted != bp_hardware_breakpoint) || thread != -1)
f8eba3c6 9821 b->pspace = current_program_space;
8bea4e01 9822
bfccc43c 9823 install_breakpoint (internal, b, 0);
0101ce28
JJ
9824 }
9825
f8eba3c6 9826 if (VEC_length (linespec_sals, canonical.sals) > 1)
95a42b64 9827 {
3e43a32a
MS
9828 warning (_("Multiple breakpoints were set.\nUse the "
9829 "\"delete\" command to delete unwanted breakpoints."));
86b17b60 9830 prev_breakpoint_count = prev_bkpt_count;
95a42b64
TT
9831 }
9832
80c99de1
PA
9833 /* That's it. Discard the cleanups for data inserted into the
9834 breakpoint. */
9835 discard_cleanups (bkpt_chain);
9836 /* But cleanup everything else. */
c3f6f71d 9837 do_cleanups (old_chain);
217dc9e2 9838
80c99de1 9839 /* error call may happen here - have BKPT_CHAIN already discarded. */
44702360 9840 update_global_location_list (UGLL_MAY_INSERT);
fd9b8c24
PA
9841
9842 return 1;
c3f6f71d 9843}
c906108c 9844
348d480f 9845/* Set a breakpoint.
72b2ff0e
VP
9846 ARG is a string describing breakpoint address,
9847 condition, and thread.
9848 FLAG specifies if a breakpoint is hardware on,
9849 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9850 and BP_TEMPFLAG. */
348d480f 9851
98deb0da 9852static void
72b2ff0e 9853break_command_1 (char *arg, int flag, int from_tty)
c3f6f71d 9854{
72b2ff0e 9855 int tempflag = flag & BP_TEMPFLAG;
0fb4aa4b
PA
9856 enum bptype type_wanted = (flag & BP_HARDWAREFLAG
9857 ? bp_hardware_breakpoint
9858 : bp_breakpoint);
55aa24fb 9859 struct breakpoint_ops *ops;
f00aae0f
KS
9860 struct event_location *location;
9861 struct cleanup *cleanup;
9862
9863 location = string_to_event_location (&arg, current_language);
9864 cleanup = make_cleanup_delete_event_location (location);
55aa24fb
SDJ
9865
9866 /* Matching breakpoints on probes. */
5b56227b
KS
9867 if (location != NULL
9868 && event_location_type (location) == PROBE_LOCATION)
55aa24fb
SDJ
9869 ops = &bkpt_probe_breakpoint_ops;
9870 else
9871 ops = &bkpt_breakpoint_ops;
c3f6f71d 9872
8cdf0e15 9873 create_breakpoint (get_current_arch (),
f00aae0f
KS
9874 location,
9875 NULL, 0, arg, 1 /* parse arg */,
0fb4aa4b 9876 tempflag, type_wanted,
8cdf0e15
VP
9877 0 /* Ignore count */,
9878 pending_break_support,
55aa24fb 9879 ops,
8cdf0e15 9880 from_tty,
84f4c1fe 9881 1 /* enabled */,
44f238bb
PA
9882 0 /* internal */,
9883 0);
f00aae0f 9884 do_cleanups (cleanup);
c906108c
SS
9885}
9886
c906108c
SS
9887/* Helper function for break_command_1 and disassemble_command. */
9888
9889void
fba45db2 9890resolve_sal_pc (struct symtab_and_line *sal)
c906108c
SS
9891{
9892 CORE_ADDR pc;
9893
9894 if (sal->pc == 0 && sal->symtab != NULL)
9895 {
9896 if (!find_line_pc (sal->symtab, sal->line, &pc))
8a3fe4f8 9897 error (_("No line %d in file \"%s\"."),
05cba821 9898 sal->line, symtab_to_filename_for_display (sal->symtab));
c906108c 9899 sal->pc = pc;
6a048695 9900
4a64f543
MS
9901 /* If this SAL corresponds to a breakpoint inserted using a line
9902 number, then skip the function prologue if necessary. */
6a048695 9903 if (sal->explicit_line)
059acae7 9904 skip_prologue_sal (sal);
c906108c
SS
9905 }
9906
9907 if (sal->section == 0 && sal->symtab != NULL)
9908 {
346d1dfe 9909 const struct blockvector *bv;
3977b71f 9910 const struct block *b;
c5aa993b 9911 struct symbol *sym;
c906108c 9912
43f3e411
DE
9913 bv = blockvector_for_pc_sect (sal->pc, 0, &b,
9914 SYMTAB_COMPUNIT (sal->symtab));
c906108c
SS
9915 if (bv != NULL)
9916 {
7f0df278 9917 sym = block_linkage_function (b);
c906108c
SS
9918 if (sym != NULL)
9919 {
eb822aa6
DE
9920 fixup_symbol_section (sym, SYMTAB_OBJFILE (sal->symtab));
9921 sal->section = SYMBOL_OBJ_SECTION (SYMTAB_OBJFILE (sal->symtab),
9922 sym);
c906108c
SS
9923 }
9924 else
9925 {
4a64f543
MS
9926 /* It really is worthwhile to have the section, so we'll
9927 just have to look harder. This case can be executed
9928 if we have line numbers but no functions (as can
9929 happen in assembly source). */
c906108c 9930
7cbd4a93 9931 struct bound_minimal_symbol msym;
6c95b8df
PA
9932 struct cleanup *old_chain = save_current_space_and_thread ();
9933
9934 switch_to_program_space_and_thread (sal->pspace);
c906108c
SS
9935
9936 msym = lookup_minimal_symbol_by_pc (sal->pc);
7cbd4a93 9937 if (msym.minsym)
efd66ac6 9938 sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
6c95b8df
PA
9939
9940 do_cleanups (old_chain);
c906108c
SS
9941 }
9942 }
9943 }
9944}
9945
9946void
fba45db2 9947break_command (char *arg, int from_tty)
c906108c 9948{
db107f19 9949 break_command_1 (arg, 0, from_tty);
c906108c
SS
9950}
9951
c906108c 9952void
fba45db2 9953tbreak_command (char *arg, int from_tty)
c906108c 9954{
db107f19 9955 break_command_1 (arg, BP_TEMPFLAG, from_tty);
c906108c
SS
9956}
9957
c906108c 9958static void
fba45db2 9959hbreak_command (char *arg, int from_tty)
c906108c 9960{
db107f19 9961 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
c906108c
SS
9962}
9963
9964static void
fba45db2 9965thbreak_command (char *arg, int from_tty)
c906108c 9966{
db107f19 9967 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
c906108c
SS
9968}
9969
9970static void
fba45db2 9971stop_command (char *arg, int from_tty)
c906108c 9972{
a3f17187 9973 printf_filtered (_("Specify the type of breakpoint to set.\n\
c906108c 9974Usage: stop in <function | address>\n\
a3f17187 9975 stop at <line>\n"));
c906108c
SS
9976}
9977
9978static void
fba45db2 9979stopin_command (char *arg, int from_tty)
c906108c
SS
9980{
9981 int badInput = 0;
9982
c5aa993b 9983 if (arg == (char *) NULL)
c906108c
SS
9984 badInput = 1;
9985 else if (*arg != '*')
9986 {
9987 char *argptr = arg;
9988 int hasColon = 0;
9989
4a64f543 9990 /* Look for a ':'. If this is a line number specification, then
53a5351d 9991 say it is bad, otherwise, it should be an address or
4a64f543 9992 function/method name. */
c906108c 9993 while (*argptr && !hasColon)
c5aa993b
JM
9994 {
9995 hasColon = (*argptr == ':');
9996 argptr++;
9997 }
c906108c
SS
9998
9999 if (hasColon)
c5aa993b 10000 badInput = (*argptr != ':'); /* Not a class::method */
c906108c 10001 else
c5aa993b 10002 badInput = isdigit (*arg); /* a simple line number */
c906108c
SS
10003 }
10004
10005 if (badInput)
a3f17187 10006 printf_filtered (_("Usage: stop in <function | address>\n"));
c906108c 10007 else
db107f19 10008 break_command_1 (arg, 0, from_tty);
c906108c
SS
10009}
10010
10011static void
fba45db2 10012stopat_command (char *arg, int from_tty)
c906108c
SS
10013{
10014 int badInput = 0;
10015
c5aa993b 10016 if (arg == (char *) NULL || *arg == '*') /* no line number */
c906108c
SS
10017 badInput = 1;
10018 else
10019 {
10020 char *argptr = arg;
10021 int hasColon = 0;
10022
4a64f543
MS
10023 /* Look for a ':'. If there is a '::' then get out, otherwise
10024 it is probably a line number. */
c906108c 10025 while (*argptr && !hasColon)
c5aa993b
JM
10026 {
10027 hasColon = (*argptr == ':');
10028 argptr++;
10029 }
c906108c
SS
10030
10031 if (hasColon)
c5aa993b 10032 badInput = (*argptr == ':'); /* we have class::method */
c906108c 10033 else
c5aa993b 10034 badInput = !isdigit (*arg); /* not a line number */
c906108c
SS
10035 }
10036
10037 if (badInput)
a3f17187 10038 printf_filtered (_("Usage: stop at <line>\n"));
c906108c 10039 else
db107f19 10040 break_command_1 (arg, 0, from_tty);
c906108c
SS
10041}
10042
e7e0cddf
SS
10043/* The dynamic printf command is mostly like a regular breakpoint, but
10044 with a prewired command list consisting of a single output command,
10045 built from extra arguments supplied on the dprintf command
10046 line. */
10047
da821c7b 10048static void
e7e0cddf
SS
10049dprintf_command (char *arg, int from_tty)
10050{
f00aae0f
KS
10051 struct event_location *location;
10052 struct cleanup *cleanup;
10053
10054 location = string_to_event_location (&arg, current_language);
10055 cleanup = make_cleanup_delete_event_location (location);
10056
10057 /* If non-NULL, ARG should have been advanced past the location;
10058 the next character must be ','. */
10059 if (arg != NULL)
10060 {
10061 if (arg[0] != ',' || arg[1] == '\0')
10062 error (_("Format string required"));
10063 else
10064 {
10065 /* Skip the comma. */
10066 ++arg;
10067 }
10068 }
10069
e7e0cddf 10070 create_breakpoint (get_current_arch (),
f00aae0f
KS
10071 location,
10072 NULL, 0, arg, 1 /* parse arg */,
e7e0cddf
SS
10073 0, bp_dprintf,
10074 0 /* Ignore count */,
10075 pending_break_support,
10076 &dprintf_breakpoint_ops,
10077 from_tty,
10078 1 /* enabled */,
10079 0 /* internal */,
10080 0);
f00aae0f 10081 do_cleanups (cleanup);
e7e0cddf
SS
10082}
10083
d3ce09f5
SS
10084static void
10085agent_printf_command (char *arg, int from_tty)
10086{
10087 error (_("May only run agent-printf on the target"));
10088}
10089
f1310107
TJB
10090/* Implement the "breakpoint_hit" breakpoint_ops method for
10091 ranged breakpoints. */
10092
10093static int
10094breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
10095 struct address_space *aspace,
09ac7c10
TT
10096 CORE_ADDR bp_addr,
10097 const struct target_waitstatus *ws)
f1310107 10098{
09ac7c10 10099 if (ws->kind != TARGET_WAITKIND_STOPPED
a493e3e2 10100 || ws->value.sig != GDB_SIGNAL_TRAP)
09ac7c10
TT
10101 return 0;
10102
f1310107
TJB
10103 return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
10104 bl->length, aspace, bp_addr);
10105}
10106
10107/* Implement the "resources_needed" breakpoint_ops method for
10108 ranged breakpoints. */
10109
10110static int
10111resources_needed_ranged_breakpoint (const struct bp_location *bl)
10112{
10113 return target_ranged_break_num_registers ();
10114}
10115
10116/* Implement the "print_it" breakpoint_ops method for
10117 ranged breakpoints. */
10118
10119static enum print_stop_action
348d480f 10120print_it_ranged_breakpoint (bpstat bs)
f1310107 10121{
348d480f 10122 struct breakpoint *b = bs->breakpoint_at;
f1310107 10123 struct bp_location *bl = b->loc;
79a45e25 10124 struct ui_out *uiout = current_uiout;
f1310107
TJB
10125
10126 gdb_assert (b->type == bp_hardware_breakpoint);
10127
10128 /* Ranged breakpoints have only one location. */
10129 gdb_assert (bl && bl->next == NULL);
10130
10131 annotate_breakpoint (b->number);
10132 if (b->disposition == disp_del)
10133 ui_out_text (uiout, "\nTemporary ranged breakpoint ");
10134 else
10135 ui_out_text (uiout, "\nRanged breakpoint ");
10136 if (ui_out_is_mi_like_p (uiout))
10137 {
10138 ui_out_field_string (uiout, "reason",
10139 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
10140 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
10141 }
10142 ui_out_field_int (uiout, "bkptno", b->number);
10143 ui_out_text (uiout, ", ");
10144
10145 return PRINT_SRC_AND_LOC;
10146}
10147
10148/* Implement the "print_one" breakpoint_ops method for
10149 ranged breakpoints. */
10150
10151static void
10152print_one_ranged_breakpoint (struct breakpoint *b,
10153 struct bp_location **last_loc)
10154{
10155 struct bp_location *bl = b->loc;
10156 struct value_print_options opts;
79a45e25 10157 struct ui_out *uiout = current_uiout;
f1310107
TJB
10158
10159 /* Ranged breakpoints have only one location. */
10160 gdb_assert (bl && bl->next == NULL);
10161
10162 get_user_print_options (&opts);
10163
10164 if (opts.addressprint)
10165 /* We don't print the address range here, it will be printed later
10166 by print_one_detail_ranged_breakpoint. */
10167 ui_out_field_skip (uiout, "addr");
10168 annotate_field (5);
10169 print_breakpoint_location (b, bl);
10170 *last_loc = bl;
10171}
10172
10173/* Implement the "print_one_detail" breakpoint_ops method for
10174 ranged breakpoints. */
10175
10176static void
10177print_one_detail_ranged_breakpoint (const struct breakpoint *b,
10178 struct ui_out *uiout)
10179{
10180 CORE_ADDR address_start, address_end;
10181 struct bp_location *bl = b->loc;
f99d8bf4
PA
10182 struct ui_file *stb = mem_fileopen ();
10183 struct cleanup *cleanup = make_cleanup_ui_file_delete (stb);
f1310107
TJB
10184
10185 gdb_assert (bl);
10186
10187 address_start = bl->address;
10188 address_end = address_start + bl->length - 1;
10189
10190 ui_out_text (uiout, "\taddress range: ");
f99d8bf4 10191 fprintf_unfiltered (stb, "[%s, %s]",
f1310107
TJB
10192 print_core_address (bl->gdbarch, address_start),
10193 print_core_address (bl->gdbarch, address_end));
10194 ui_out_field_stream (uiout, "addr", stb);
10195 ui_out_text (uiout, "\n");
10196
10197 do_cleanups (cleanup);
10198}
10199
10200/* Implement the "print_mention" breakpoint_ops method for
10201 ranged breakpoints. */
10202
10203static void
10204print_mention_ranged_breakpoint (struct breakpoint *b)
10205{
10206 struct bp_location *bl = b->loc;
79a45e25 10207 struct ui_out *uiout = current_uiout;
f1310107
TJB
10208
10209 gdb_assert (bl);
10210 gdb_assert (b->type == bp_hardware_breakpoint);
10211
10212 if (ui_out_is_mi_like_p (uiout))
10213 return;
10214
10215 printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
10216 b->number, paddress (bl->gdbarch, bl->address),
10217 paddress (bl->gdbarch, bl->address + bl->length - 1));
10218}
10219
10220/* Implement the "print_recreate" breakpoint_ops method for
10221 ranged breakpoints. */
10222
10223static void
10224print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
10225{
f00aae0f
KS
10226 fprintf_unfiltered (fp, "break-range %s, %s",
10227 event_location_to_string (b->location),
10228 event_location_to_string (b->location_range_end));
d9b3f62e 10229 print_recreate_thread (b, fp);
f1310107
TJB
10230}
10231
10232/* The breakpoint_ops structure to be used in ranged breakpoints. */
10233
2060206e 10234static struct breakpoint_ops ranged_breakpoint_ops;
f1310107
TJB
10235
10236/* Find the address where the end of the breakpoint range should be
10237 placed, given the SAL of the end of the range. This is so that if
10238 the user provides a line number, the end of the range is set to the
10239 last instruction of the given line. */
10240
10241static CORE_ADDR
10242find_breakpoint_range_end (struct symtab_and_line sal)
10243{
10244 CORE_ADDR end;
10245
10246 /* If the user provided a PC value, use it. Otherwise,
10247 find the address of the end of the given location. */
10248 if (sal.explicit_pc)
10249 end = sal.pc;
10250 else
10251 {
10252 int ret;
10253 CORE_ADDR start;
10254
10255 ret = find_line_pc_range (sal, &start, &end);
10256 if (!ret)
10257 error (_("Could not find location of the end of the range."));
10258
10259 /* find_line_pc_range returns the start of the next line. */
10260 end--;
10261 }
10262
10263 return end;
10264}
10265
10266/* Implement the "break-range" CLI command. */
10267
10268static void
10269break_range_command (char *arg, int from_tty)
10270{
10271 char *arg_start, *addr_string_start, *addr_string_end;
10272 struct linespec_result canonical_start, canonical_end;
10273 int bp_count, can_use_bp, length;
10274 CORE_ADDR end;
10275 struct breakpoint *b;
10276 struct symtab_and_line sal_start, sal_end;
f1310107 10277 struct cleanup *cleanup_bkpt;
f8eba3c6 10278 struct linespec_sals *lsal_start, *lsal_end;
f00aae0f 10279 struct event_location *start_location, *end_location;
f1310107
TJB
10280
10281 /* We don't support software ranged breakpoints. */
10282 if (target_ranged_break_num_registers () < 0)
10283 error (_("This target does not support hardware ranged breakpoints."));
10284
10285 bp_count = hw_breakpoint_used_count ();
10286 bp_count += target_ranged_break_num_registers ();
10287 can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
10288 bp_count, 0);
10289 if (can_use_bp < 0)
10290 error (_("Hardware breakpoints used exceeds limit."));
10291
f8eba3c6 10292 arg = skip_spaces (arg);
f1310107
TJB
10293 if (arg == NULL || arg[0] == '\0')
10294 error(_("No address range specified."));
10295
f1310107
TJB
10296 init_linespec_result (&canonical_start);
10297
f8eba3c6 10298 arg_start = arg;
f00aae0f
KS
10299 start_location = string_to_event_location (&arg, current_language);
10300 cleanup_bkpt = make_cleanup_delete_event_location (start_location);
10301 parse_breakpoint_sals (start_location, &canonical_start);
10302 make_cleanup_destroy_linespec_result (&canonical_start);
f1310107
TJB
10303
10304 if (arg[0] != ',')
10305 error (_("Too few arguments."));
f8eba3c6 10306 else if (VEC_empty (linespec_sals, canonical_start.sals))
f1310107 10307 error (_("Could not find location of the beginning of the range."));
f8eba3c6
TT
10308
10309 lsal_start = VEC_index (linespec_sals, canonical_start.sals, 0);
10310
10311 if (VEC_length (linespec_sals, canonical_start.sals) > 1
10312 || lsal_start->sals.nelts != 1)
f1310107
TJB
10313 error (_("Cannot create a ranged breakpoint with multiple locations."));
10314
f8eba3c6
TT
10315 sal_start = lsal_start->sals.sals[0];
10316 addr_string_start = savestring (arg_start, arg - arg_start);
10317 make_cleanup (xfree, addr_string_start);
f1310107
TJB
10318
10319 arg++; /* Skip the comma. */
f8eba3c6 10320 arg = skip_spaces (arg);
f1310107
TJB
10321
10322 /* Parse the end location. */
10323
f1310107
TJB
10324 init_linespec_result (&canonical_end);
10325 arg_start = arg;
10326
f8eba3c6 10327 /* We call decode_line_full directly here instead of using
f1310107
TJB
10328 parse_breakpoint_sals because we need to specify the start location's
10329 symtab and line as the default symtab and line for the end of the
10330 range. This makes it possible to have ranges like "foo.c:27, +14",
10331 where +14 means 14 lines from the start location. */
f00aae0f
KS
10332 end_location = string_to_event_location (&arg, current_language);
10333 make_cleanup_delete_event_location (end_location);
10334 decode_line_full (end_location, DECODE_LINE_FUNFIRSTLINE,
f8eba3c6
TT
10335 sal_start.symtab, sal_start.line,
10336 &canonical_end, NULL, NULL);
10337
10338 make_cleanup_destroy_linespec_result (&canonical_end);
f1310107 10339
f8eba3c6 10340 if (VEC_empty (linespec_sals, canonical_end.sals))
f1310107 10341 error (_("Could not find location of the end of the range."));
f8eba3c6
TT
10342
10343 lsal_end = VEC_index (linespec_sals, canonical_end.sals, 0);
10344 if (VEC_length (linespec_sals, canonical_end.sals) > 1
10345 || lsal_end->sals.nelts != 1)
f1310107
TJB
10346 error (_("Cannot create a ranged breakpoint with multiple locations."));
10347
f8eba3c6 10348 sal_end = lsal_end->sals.sals[0];
f1310107
TJB
10349
10350 end = find_breakpoint_range_end (sal_end);
10351 if (sal_start.pc > end)
177b42fe 10352 error (_("Invalid address range, end precedes start."));
f1310107
TJB
10353
10354 length = end - sal_start.pc + 1;
10355 if (length < 0)
10356 /* Length overflowed. */
10357 error (_("Address range too large."));
10358 else if (length == 1)
10359 {
10360 /* This range is simple enough to be handled by
10361 the `hbreak' command. */
10362 hbreak_command (addr_string_start, 1);
10363
10364 do_cleanups (cleanup_bkpt);
10365
10366 return;
10367 }
10368
10369 /* Now set up the breakpoint. */
10370 b = set_raw_breakpoint (get_current_arch (), sal_start,
348d480f 10371 bp_hardware_breakpoint, &ranged_breakpoint_ops);
f1310107
TJB
10372 set_breakpoint_count (breakpoint_count + 1);
10373 b->number = breakpoint_count;
10374 b->disposition = disp_donttouch;
f00aae0f
KS
10375 b->location = copy_event_location (start_location);
10376 b->location_range_end = copy_event_location (end_location);
f1310107
TJB
10377 b->loc->length = length;
10378
f8eba3c6 10379 do_cleanups (cleanup_bkpt);
f1310107
TJB
10380
10381 mention (b);
8d3788bd 10382 observer_notify_breakpoint_created (b);
44702360 10383 update_global_location_list (UGLL_MAY_INSERT);
f1310107
TJB
10384}
10385
4a64f543
MS
10386/* Return non-zero if EXP is verified as constant. Returned zero
10387 means EXP is variable. Also the constant detection may fail for
10388 some constant expressions and in such case still falsely return
10389 zero. */
2e6e3d9c 10390
65d79d4b
SDJ
10391static int
10392watchpoint_exp_is_const (const struct expression *exp)
10393{
10394 int i = exp->nelts;
10395
10396 while (i > 0)
10397 {
10398 int oplenp, argsp;
10399
10400 /* We are only interested in the descriptor of each element. */
10401 operator_length (exp, i, &oplenp, &argsp);
10402 i -= oplenp;
10403
10404 switch (exp->elts[i].opcode)
10405 {
10406 case BINOP_ADD:
10407 case BINOP_SUB:
10408 case BINOP_MUL:
10409 case BINOP_DIV:
10410 case BINOP_REM:
10411 case BINOP_MOD:
10412 case BINOP_LSH:
10413 case BINOP_RSH:
10414 case BINOP_LOGICAL_AND:
10415 case BINOP_LOGICAL_OR:
10416 case BINOP_BITWISE_AND:
10417 case BINOP_BITWISE_IOR:
10418 case BINOP_BITWISE_XOR:
10419 case BINOP_EQUAL:
10420 case BINOP_NOTEQUAL:
10421 case BINOP_LESS:
10422 case BINOP_GTR:
10423 case BINOP_LEQ:
10424 case BINOP_GEQ:
10425 case BINOP_REPEAT:
10426 case BINOP_COMMA:
10427 case BINOP_EXP:
10428 case BINOP_MIN:
10429 case BINOP_MAX:
10430 case BINOP_INTDIV:
10431 case BINOP_CONCAT:
65d79d4b
SDJ
10432 case TERNOP_COND:
10433 case TERNOP_SLICE:
65d79d4b
SDJ
10434
10435 case OP_LONG:
10436 case OP_DOUBLE:
10437 case OP_DECFLOAT:
10438 case OP_LAST:
10439 case OP_COMPLEX:
10440 case OP_STRING:
65d79d4b
SDJ
10441 case OP_ARRAY:
10442 case OP_TYPE:
608b4967
TT
10443 case OP_TYPEOF:
10444 case OP_DECLTYPE:
6e72ca20 10445 case OP_TYPEID:
65d79d4b
SDJ
10446 case OP_NAME:
10447 case OP_OBJC_NSSTRING:
10448
10449 case UNOP_NEG:
10450 case UNOP_LOGICAL_NOT:
10451 case UNOP_COMPLEMENT:
10452 case UNOP_ADDR:
10453 case UNOP_HIGH:
aeaa2474 10454 case UNOP_CAST:
9eaf6705
TT
10455
10456 case UNOP_CAST_TYPE:
10457 case UNOP_REINTERPRET_CAST:
10458 case UNOP_DYNAMIC_CAST:
4a64f543
MS
10459 /* Unary, binary and ternary operators: We have to check
10460 their operands. If they are constant, then so is the
10461 result of that operation. For instance, if A and B are
10462 determined to be constants, then so is "A + B".
10463
10464 UNOP_IND is one exception to the rule above, because the
10465 value of *ADDR is not necessarily a constant, even when
10466 ADDR is. */
65d79d4b
SDJ
10467 break;
10468
10469 case OP_VAR_VALUE:
10470 /* Check whether the associated symbol is a constant.
4a64f543 10471
65d79d4b 10472 We use SYMBOL_CLASS rather than TYPE_CONST because it's
4a64f543
MS
10473 possible that a buggy compiler could mark a variable as
10474 constant even when it is not, and TYPE_CONST would return
10475 true in this case, while SYMBOL_CLASS wouldn't.
10476
10477 We also have to check for function symbols because they
10478 are always constant. */
65d79d4b
SDJ
10479 {
10480 struct symbol *s = exp->elts[i + 2].symbol;
10481
10482 if (SYMBOL_CLASS (s) != LOC_BLOCK
10483 && SYMBOL_CLASS (s) != LOC_CONST
10484 && SYMBOL_CLASS (s) != LOC_CONST_BYTES)
10485 return 0;
10486 break;
10487 }
10488
10489 /* The default action is to return 0 because we are using
10490 the optimistic approach here: If we don't know something,
10491 then it is not a constant. */
10492 default:
10493 return 0;
10494 }
10495 }
10496
10497 return 1;
10498}
10499
3a5c3e22
PA
10500/* Implement the "dtor" breakpoint_ops method for watchpoints. */
10501
10502static void
10503dtor_watchpoint (struct breakpoint *self)
10504{
10505 struct watchpoint *w = (struct watchpoint *) self;
10506
10507 xfree (w->cond_exp);
10508 xfree (w->exp);
10509 xfree (w->exp_string);
10510 xfree (w->exp_string_reparse);
10511 value_free (w->val);
10512
10513 base_breakpoint_ops.dtor (self);
10514}
10515
348d480f
PA
10516/* Implement the "re_set" breakpoint_ops method for watchpoints. */
10517
10518static void
10519re_set_watchpoint (struct breakpoint *b)
10520{
3a5c3e22
PA
10521 struct watchpoint *w = (struct watchpoint *) b;
10522
348d480f
PA
10523 /* Watchpoint can be either on expression using entirely global
10524 variables, or it can be on local variables.
10525
10526 Watchpoints of the first kind are never auto-deleted, and even
10527 persist across program restarts. Since they can use variables
10528 from shared libraries, we need to reparse expression as libraries
10529 are loaded and unloaded.
10530
10531 Watchpoints on local variables can also change meaning as result
10532 of solib event. For example, if a watchpoint uses both a local
10533 and a global variables in expression, it's a local watchpoint,
10534 but unloading of a shared library will make the expression
10535 invalid. This is not a very common use case, but we still
10536 re-evaluate expression, to avoid surprises to the user.
10537
10538 Note that for local watchpoints, we re-evaluate it only if
10539 watchpoints frame id is still valid. If it's not, it means the
10540 watchpoint is out of scope and will be deleted soon. In fact,
10541 I'm not sure we'll ever be called in this case.
10542
10543 If a local watchpoint's frame id is still valid, then
3a5c3e22 10544 w->exp_valid_block is likewise valid, and we can safely use it.
348d480f 10545
3a5c3e22
PA
10546 Don't do anything about disabled watchpoints, since they will be
10547 reevaluated again when enabled. */
10548 update_watchpoint (w, 1 /* reparse */);
348d480f
PA
10549}
10550
77b06cd7
TJB
10551/* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10552
10553static int
10554insert_watchpoint (struct bp_location *bl)
10555{
3a5c3e22
PA
10556 struct watchpoint *w = (struct watchpoint *) bl->owner;
10557 int length = w->exact ? 1 : bl->length;
e09342b5
TJB
10558
10559 return target_insert_watchpoint (bl->address, length, bl->watchpoint_type,
3a5c3e22 10560 w->cond_exp);
77b06cd7
TJB
10561}
10562
10563/* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10564
10565static int
10566remove_watchpoint (struct bp_location *bl)
10567{
3a5c3e22
PA
10568 struct watchpoint *w = (struct watchpoint *) bl->owner;
10569 int length = w->exact ? 1 : bl->length;
e09342b5
TJB
10570
10571 return target_remove_watchpoint (bl->address, length, bl->watchpoint_type,
3a5c3e22 10572 w->cond_exp);
e09342b5
TJB
10573}
10574
e09342b5 10575static int
348d480f 10576breakpoint_hit_watchpoint (const struct bp_location *bl,
09ac7c10
TT
10577 struct address_space *aspace, CORE_ADDR bp_addr,
10578 const struct target_waitstatus *ws)
e09342b5 10579{
348d480f 10580 struct breakpoint *b = bl->owner;
3a5c3e22 10581 struct watchpoint *w = (struct watchpoint *) b;
77b06cd7 10582
348d480f
PA
10583 /* Continuable hardware watchpoints are treated as non-existent if the
10584 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10585 some data address). Otherwise gdb won't stop on a break instruction
10586 in the code (not from a breakpoint) when a hardware watchpoint has
10587 been defined. Also skip watchpoints which we know did not trigger
10588 (did not match the data address). */
10589 if (is_hardware_watchpoint (b)
3a5c3e22 10590 && w->watchpoint_triggered == watch_triggered_no)
348d480f 10591 return 0;
9c06b0b4 10592
348d480f 10593 return 1;
9c06b0b4
TJB
10594}
10595
348d480f
PA
10596static void
10597check_status_watchpoint (bpstat bs)
9c06b0b4 10598{
348d480f 10599 gdb_assert (is_watchpoint (bs->breakpoint_at));
9c06b0b4 10600
348d480f 10601 bpstat_check_watchpoint (bs);
9c06b0b4
TJB
10602}
10603
10604/* Implement the "resources_needed" breakpoint_ops method for
348d480f 10605 hardware watchpoints. */
9c06b0b4
TJB
10606
10607static int
348d480f 10608resources_needed_watchpoint (const struct bp_location *bl)
9c06b0b4 10609{
3a5c3e22
PA
10610 struct watchpoint *w = (struct watchpoint *) bl->owner;
10611 int length = w->exact? 1 : bl->length;
348d480f
PA
10612
10613 return target_region_ok_for_hw_watchpoint (bl->address, length);
9c06b0b4
TJB
10614}
10615
10616/* Implement the "works_in_software_mode" breakpoint_ops method for
348d480f 10617 hardware watchpoints. */
9c06b0b4
TJB
10618
10619static int
348d480f 10620works_in_software_mode_watchpoint (const struct breakpoint *b)
9c06b0b4 10621{
efa80663
PA
10622 /* Read and access watchpoints only work with hardware support. */
10623 return b->type == bp_watchpoint || b->type == bp_hardware_watchpoint;
9c06b0b4
TJB
10624}
10625
9c06b0b4 10626static enum print_stop_action
348d480f 10627print_it_watchpoint (bpstat bs)
9c06b0b4 10628{
348d480f
PA
10629 struct cleanup *old_chain;
10630 struct breakpoint *b;
f99d8bf4 10631 struct ui_file *stb;
348d480f 10632 enum print_stop_action result;
3a5c3e22 10633 struct watchpoint *w;
79a45e25 10634 struct ui_out *uiout = current_uiout;
348d480f
PA
10635
10636 gdb_assert (bs->bp_location_at != NULL);
10637
348d480f 10638 b = bs->breakpoint_at;
3a5c3e22 10639 w = (struct watchpoint *) b;
348d480f 10640
f99d8bf4
PA
10641 stb = mem_fileopen ();
10642 old_chain = make_cleanup_ui_file_delete (stb);
9c06b0b4
TJB
10643
10644 switch (b->type)
10645 {
348d480f 10646 case bp_watchpoint:
9c06b0b4
TJB
10647 case bp_hardware_watchpoint:
10648 annotate_watchpoint (b->number);
10649 if (ui_out_is_mi_like_p (uiout))
10650 ui_out_field_string
10651 (uiout, "reason",
10652 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
348d480f
PA
10653 mention (b);
10654 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10655 ui_out_text (uiout, "\nOld value = ");
f99d8bf4 10656 watchpoint_value_print (bs->old_val, stb);
348d480f
PA
10657 ui_out_field_stream (uiout, "old", stb);
10658 ui_out_text (uiout, "\nNew value = ");
f99d8bf4 10659 watchpoint_value_print (w->val, stb);
348d480f
PA
10660 ui_out_field_stream (uiout, "new", stb);
10661 ui_out_text (uiout, "\n");
10662 /* More than one watchpoint may have been triggered. */
10663 result = PRINT_UNKNOWN;
9c06b0b4
TJB
10664 break;
10665
10666 case bp_read_watchpoint:
10667 if (ui_out_is_mi_like_p (uiout))
10668 ui_out_field_string
10669 (uiout, "reason",
10670 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
348d480f
PA
10671 mention (b);
10672 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10673 ui_out_text (uiout, "\nValue = ");
f99d8bf4 10674 watchpoint_value_print (w->val, stb);
348d480f
PA
10675 ui_out_field_stream (uiout, "value", stb);
10676 ui_out_text (uiout, "\n");
10677 result = PRINT_UNKNOWN;
9c06b0b4
TJB
10678 break;
10679
10680 case bp_access_watchpoint:
348d480f
PA
10681 if (bs->old_val != NULL)
10682 {
10683 annotate_watchpoint (b->number);
10684 if (ui_out_is_mi_like_p (uiout))
10685 ui_out_field_string
10686 (uiout, "reason",
10687 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10688 mention (b);
10689 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10690 ui_out_text (uiout, "\nOld value = ");
f99d8bf4 10691 watchpoint_value_print (bs->old_val, stb);
348d480f
PA
10692 ui_out_field_stream (uiout, "old", stb);
10693 ui_out_text (uiout, "\nNew value = ");
10694 }
10695 else
10696 {
10697 mention (b);
10698 if (ui_out_is_mi_like_p (uiout))
10699 ui_out_field_string
10700 (uiout, "reason",
10701 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10702 make_cleanup_ui_out_tuple_begin_end (uiout, "value");
10703 ui_out_text (uiout, "\nValue = ");
10704 }
f99d8bf4 10705 watchpoint_value_print (w->val, stb);
348d480f
PA
10706 ui_out_field_stream (uiout, "new", stb);
10707 ui_out_text (uiout, "\n");
10708 result = PRINT_UNKNOWN;
9c06b0b4
TJB
10709 break;
10710 default:
348d480f 10711 result = PRINT_UNKNOWN;
9c06b0b4
TJB
10712 }
10713
348d480f
PA
10714 do_cleanups (old_chain);
10715 return result;
10716}
10717
10718/* Implement the "print_mention" breakpoint_ops method for hardware
10719 watchpoints. */
10720
10721static void
10722print_mention_watchpoint (struct breakpoint *b)
10723{
10724 struct cleanup *ui_out_chain;
3a5c3e22 10725 struct watchpoint *w = (struct watchpoint *) b;
79a45e25 10726 struct ui_out *uiout = current_uiout;
348d480f
PA
10727
10728 switch (b->type)
10729 {
10730 case bp_watchpoint:
10731 ui_out_text (uiout, "Watchpoint ");
10732 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10733 break;
10734 case bp_hardware_watchpoint:
10735 ui_out_text (uiout, "Hardware watchpoint ");
10736 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10737 break;
10738 case bp_read_watchpoint:
10739 ui_out_text (uiout, "Hardware read watchpoint ");
10740 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10741 break;
10742 case bp_access_watchpoint:
10743 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
10744 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10745 break;
10746 default:
10747 internal_error (__FILE__, __LINE__,
10748 _("Invalid hardware watchpoint type."));
10749 }
10750
10751 ui_out_field_int (uiout, "number", b->number);
10752 ui_out_text (uiout, ": ");
3a5c3e22 10753 ui_out_field_string (uiout, "exp", w->exp_string);
348d480f
PA
10754 do_cleanups (ui_out_chain);
10755}
10756
10757/* Implement the "print_recreate" breakpoint_ops method for
10758 watchpoints. */
10759
10760static void
10761print_recreate_watchpoint (struct breakpoint *b, struct ui_file *fp)
10762{
3a5c3e22
PA
10763 struct watchpoint *w = (struct watchpoint *) b;
10764
348d480f
PA
10765 switch (b->type)
10766 {
10767 case bp_watchpoint:
10768 case bp_hardware_watchpoint:
10769 fprintf_unfiltered (fp, "watch");
10770 break;
10771 case bp_read_watchpoint:
10772 fprintf_unfiltered (fp, "rwatch");
10773 break;
10774 case bp_access_watchpoint:
10775 fprintf_unfiltered (fp, "awatch");
10776 break;
10777 default:
10778 internal_error (__FILE__, __LINE__,
10779 _("Invalid watchpoint type."));
10780 }
10781
3a5c3e22 10782 fprintf_unfiltered (fp, " %s", w->exp_string);
d9b3f62e 10783 print_recreate_thread (b, fp);
348d480f
PA
10784}
10785
427cd150
TT
10786/* Implement the "explains_signal" breakpoint_ops method for
10787 watchpoints. */
10788
47591c29 10789static int
427cd150
TT
10790explains_signal_watchpoint (struct breakpoint *b, enum gdb_signal sig)
10791{
10792 /* A software watchpoint cannot cause a signal other than
10793 GDB_SIGNAL_TRAP. */
10794 if (b->type == bp_watchpoint && sig != GDB_SIGNAL_TRAP)
47591c29 10795 return 0;
427cd150 10796
47591c29 10797 return 1;
427cd150
TT
10798}
10799
348d480f
PA
10800/* The breakpoint_ops structure to be used in hardware watchpoints. */
10801
2060206e 10802static struct breakpoint_ops watchpoint_breakpoint_ops;
348d480f
PA
10803
10804/* Implement the "insert" breakpoint_ops method for
10805 masked hardware watchpoints. */
10806
10807static int
10808insert_masked_watchpoint (struct bp_location *bl)
10809{
3a5c3e22
PA
10810 struct watchpoint *w = (struct watchpoint *) bl->owner;
10811
10812 return target_insert_mask_watchpoint (bl->address, w->hw_wp_mask,
348d480f
PA
10813 bl->watchpoint_type);
10814}
10815
10816/* Implement the "remove" breakpoint_ops method for
10817 masked hardware watchpoints. */
10818
10819static int
10820remove_masked_watchpoint (struct bp_location *bl)
10821{
3a5c3e22
PA
10822 struct watchpoint *w = (struct watchpoint *) bl->owner;
10823
10824 return target_remove_mask_watchpoint (bl->address, w->hw_wp_mask,
348d480f
PA
10825 bl->watchpoint_type);
10826}
10827
10828/* Implement the "resources_needed" breakpoint_ops method for
10829 masked hardware watchpoints. */
10830
10831static int
10832resources_needed_masked_watchpoint (const struct bp_location *bl)
10833{
3a5c3e22
PA
10834 struct watchpoint *w = (struct watchpoint *) bl->owner;
10835
10836 return target_masked_watch_num_registers (bl->address, w->hw_wp_mask);
348d480f
PA
10837}
10838
10839/* Implement the "works_in_software_mode" breakpoint_ops method for
10840 masked hardware watchpoints. */
10841
10842static int
10843works_in_software_mode_masked_watchpoint (const struct breakpoint *b)
10844{
10845 return 0;
10846}
10847
10848/* Implement the "print_it" breakpoint_ops method for
10849 masked hardware watchpoints. */
10850
10851static enum print_stop_action
10852print_it_masked_watchpoint (bpstat bs)
10853{
10854 struct breakpoint *b = bs->breakpoint_at;
79a45e25 10855 struct ui_out *uiout = current_uiout;
348d480f
PA
10856
10857 /* Masked watchpoints have only one location. */
10858 gdb_assert (b->loc && b->loc->next == NULL);
10859
10860 switch (b->type)
10861 {
10862 case bp_hardware_watchpoint:
10863 annotate_watchpoint (b->number);
10864 if (ui_out_is_mi_like_p (uiout))
10865 ui_out_field_string
10866 (uiout, "reason",
10867 async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER));
10868 break;
10869
10870 case bp_read_watchpoint:
10871 if (ui_out_is_mi_like_p (uiout))
10872 ui_out_field_string
10873 (uiout, "reason",
10874 async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER));
10875 break;
10876
10877 case bp_access_watchpoint:
10878 if (ui_out_is_mi_like_p (uiout))
10879 ui_out_field_string
10880 (uiout, "reason",
10881 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER));
10882 break;
10883 default:
10884 internal_error (__FILE__, __LINE__,
10885 _("Invalid hardware watchpoint type."));
10886 }
10887
10888 mention (b);
9c06b0b4
TJB
10889 ui_out_text (uiout, _("\n\
10890Check the underlying instruction at PC for the memory\n\
10891address and value which triggered this watchpoint.\n"));
10892 ui_out_text (uiout, "\n");
10893
10894 /* More than one watchpoint may have been triggered. */
10895 return PRINT_UNKNOWN;
10896}
10897
10898/* Implement the "print_one_detail" breakpoint_ops method for
10899 masked hardware watchpoints. */
10900
10901static void
10902print_one_detail_masked_watchpoint (const struct breakpoint *b,
10903 struct ui_out *uiout)
10904{
3a5c3e22
PA
10905 struct watchpoint *w = (struct watchpoint *) b;
10906
9c06b0b4
TJB
10907 /* Masked watchpoints have only one location. */
10908 gdb_assert (b->loc && b->loc->next == NULL);
10909
10910 ui_out_text (uiout, "\tmask ");
3a5c3e22 10911 ui_out_field_core_addr (uiout, "mask", b->loc->gdbarch, w->hw_wp_mask);
9c06b0b4
TJB
10912 ui_out_text (uiout, "\n");
10913}
10914
10915/* Implement the "print_mention" breakpoint_ops method for
10916 masked hardware watchpoints. */
10917
10918static void
10919print_mention_masked_watchpoint (struct breakpoint *b)
10920{
3a5c3e22 10921 struct watchpoint *w = (struct watchpoint *) b;
79a45e25 10922 struct ui_out *uiout = current_uiout;
9c06b0b4
TJB
10923 struct cleanup *ui_out_chain;
10924
10925 switch (b->type)
10926 {
10927 case bp_hardware_watchpoint:
10928 ui_out_text (uiout, "Masked hardware watchpoint ");
10929 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
10930 break;
10931 case bp_read_watchpoint:
10932 ui_out_text (uiout, "Masked hardware read watchpoint ");
10933 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
10934 break;
10935 case bp_access_watchpoint:
10936 ui_out_text (uiout, "Masked hardware access (read/write) watchpoint ");
10937 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
10938 break;
10939 default:
10940 internal_error (__FILE__, __LINE__,
10941 _("Invalid hardware watchpoint type."));
10942 }
10943
10944 ui_out_field_int (uiout, "number", b->number);
10945 ui_out_text (uiout, ": ");
3a5c3e22 10946 ui_out_field_string (uiout, "exp", w->exp_string);
9c06b0b4
TJB
10947 do_cleanups (ui_out_chain);
10948}
10949
10950/* Implement the "print_recreate" breakpoint_ops method for
10951 masked hardware watchpoints. */
10952
10953static void
10954print_recreate_masked_watchpoint (struct breakpoint *b, struct ui_file *fp)
10955{
3a5c3e22 10956 struct watchpoint *w = (struct watchpoint *) b;
9c06b0b4
TJB
10957 char tmp[40];
10958
10959 switch (b->type)
10960 {
10961 case bp_hardware_watchpoint:
10962 fprintf_unfiltered (fp, "watch");
10963 break;
10964 case bp_read_watchpoint:
10965 fprintf_unfiltered (fp, "rwatch");
10966 break;
10967 case bp_access_watchpoint:
10968 fprintf_unfiltered (fp, "awatch");
10969 break;
10970 default:
10971 internal_error (__FILE__, __LINE__,
10972 _("Invalid hardware watchpoint type."));
10973 }
10974
3a5c3e22
PA
10975 sprintf_vma (tmp, w->hw_wp_mask);
10976 fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
d9b3f62e 10977 print_recreate_thread (b, fp);
9c06b0b4
TJB
10978}
10979
10980/* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10981
2060206e 10982static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
9c06b0b4
TJB
10983
10984/* Tell whether the given watchpoint is a masked hardware watchpoint. */
10985
10986static int
10987is_masked_watchpoint (const struct breakpoint *b)
10988{
10989 return b->ops == &masked_watchpoint_breakpoint_ops;
10990}
10991
53a5351d
JM
10992/* accessflag: hw_write: watch write,
10993 hw_read: watch read,
10994 hw_access: watch access (read or write) */
c906108c 10995static void
bbc13ae3 10996watch_command_1 (const char *arg, int accessflag, int from_tty,
84f4c1fe 10997 int just_location, int internal)
c906108c 10998{
d983da9c 10999 struct breakpoint *b, *scope_breakpoint = NULL;
c906108c 11000 struct expression *exp;
270140bd 11001 const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
a1442452 11002 struct value *val, *mark, *result;
bb9d5f81 11003 int saved_bitpos = 0, saved_bitsize = 0;
c906108c 11004 struct frame_info *frame;
bbc13ae3
KS
11005 const char *exp_start = NULL;
11006 const char *exp_end = NULL;
11007 const char *tok, *end_tok;
9c06b0b4 11008 int toklen = -1;
bbc13ae3
KS
11009 const char *cond_start = NULL;
11010 const char *cond_end = NULL;
c906108c 11011 enum bptype bp_type;
37e4754d 11012 int thread = -1;
0cf6dd15 11013 int pc = 0;
9c06b0b4
TJB
11014 /* Flag to indicate whether we are going to use masks for
11015 the hardware watchpoint. */
11016 int use_mask = 0;
11017 CORE_ADDR mask = 0;
3a5c3e22 11018 struct watchpoint *w;
bbc13ae3
KS
11019 char *expression;
11020 struct cleanup *back_to;
c906108c 11021
37e4754d
LM
11022 /* Make sure that we actually have parameters to parse. */
11023 if (arg != NULL && arg[0] != '\0')
11024 {
bbc13ae3
KS
11025 const char *value_start;
11026
11027 exp_end = arg + strlen (arg);
37e4754d 11028
9c06b0b4
TJB
11029 /* Look for "parameter value" pairs at the end
11030 of the arguments string. */
bbc13ae3 11031 for (tok = exp_end - 1; tok > arg; tok--)
9c06b0b4
TJB
11032 {
11033 /* Skip whitespace at the end of the argument list. */
11034 while (tok > arg && (*tok == ' ' || *tok == '\t'))
11035 tok--;
11036
11037 /* Find the beginning of the last token.
11038 This is the value of the parameter. */
11039 while (tok > arg && (*tok != ' ' && *tok != '\t'))
11040 tok--;
11041 value_start = tok + 1;
11042
11043 /* Skip whitespace. */
11044 while (tok > arg && (*tok == ' ' || *tok == '\t'))
11045 tok--;
11046
11047 end_tok = tok;
11048
11049 /* Find the beginning of the second to last token.
11050 This is the parameter itself. */
11051 while (tok > arg && (*tok != ' ' && *tok != '\t'))
11052 tok--;
11053 tok++;
11054 toklen = end_tok - tok + 1;
11055
61012eef 11056 if (toklen == 6 && startswith (tok, "thread"))
9c06b0b4
TJB
11057 {
11058 /* At this point we've found a "thread" token, which means
11059 the user is trying to set a watchpoint that triggers
11060 only in a specific thread. */
11061 char *endp;
37e4754d 11062
9c06b0b4
TJB
11063 if (thread != -1)
11064 error(_("You can specify only one thread."));
37e4754d 11065
9c06b0b4
TJB
11066 /* Extract the thread ID from the next token. */
11067 thread = strtol (value_start, &endp, 0);
37e4754d 11068
9c06b0b4
TJB
11069 /* Check if the user provided a valid numeric value for the
11070 thread ID. */
11071 if (*endp != ' ' && *endp != '\t' && *endp != '\0')
11072 error (_("Invalid thread ID specification %s."), value_start);
11073
11074 /* Check if the thread actually exists. */
11075 if (!valid_thread_id (thread))
af4908ba 11076 invalid_thread_id_error (thread);
9c06b0b4 11077 }
61012eef 11078 else if (toklen == 4 && startswith (tok, "mask"))
9c06b0b4
TJB
11079 {
11080 /* We've found a "mask" token, which means the user wants to
11081 create a hardware watchpoint that is going to have the mask
11082 facility. */
11083 struct value *mask_value, *mark;
37e4754d 11084
9c06b0b4
TJB
11085 if (use_mask)
11086 error(_("You can specify only one mask."));
37e4754d 11087
9c06b0b4 11088 use_mask = just_location = 1;
37e4754d 11089
9c06b0b4
TJB
11090 mark = value_mark ();
11091 mask_value = parse_to_comma_and_eval (&value_start);
11092 mask = value_as_address (mask_value);
11093 value_free_to_mark (mark);
11094 }
11095 else
11096 /* We didn't recognize what we found. We should stop here. */
11097 break;
37e4754d 11098
9c06b0b4
TJB
11099 /* Truncate the string and get rid of the "parameter value" pair before
11100 the arguments string is parsed by the parse_exp_1 function. */
bbc13ae3 11101 exp_end = tok;
9c06b0b4 11102 }
37e4754d 11103 }
bbc13ae3
KS
11104 else
11105 exp_end = arg;
37e4754d 11106
bbc13ae3
KS
11107 /* Parse the rest of the arguments. From here on out, everything
11108 is in terms of a newly allocated string instead of the original
11109 ARG. */
c906108c 11110 innermost_block = NULL;
bbc13ae3
KS
11111 expression = savestring (arg, exp_end - arg);
11112 back_to = make_cleanup (xfree, expression);
11113 exp_start = arg = expression;
1bb9788d 11114 exp = parse_exp_1 (&arg, 0, 0, 0);
c906108c 11115 exp_end = arg;
fa8a61dc
TT
11116 /* Remove trailing whitespace from the expression before saving it.
11117 This makes the eventual display of the expression string a bit
11118 prettier. */
11119 while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
11120 --exp_end;
11121
65d79d4b
SDJ
11122 /* Checking if the expression is not constant. */
11123 if (watchpoint_exp_is_const (exp))
11124 {
11125 int len;
11126
11127 len = exp_end - exp_start;
11128 while (len > 0 && isspace (exp_start[len - 1]))
11129 len--;
11130 error (_("Cannot watch constant value `%.*s'."), len, exp_start);
11131 }
11132
c906108c
SS
11133 exp_valid_block = innermost_block;
11134 mark = value_mark ();
3a1115a0 11135 fetch_subexp_value (exp, &pc, &val, &result, NULL, just_location);
06a64a0b 11136
bb9d5f81
PP
11137 if (val != NULL && just_location)
11138 {
11139 saved_bitpos = value_bitpos (val);
11140 saved_bitsize = value_bitsize (val);
11141 }
11142
06a64a0b
TT
11143 if (just_location)
11144 {
9c06b0b4
TJB
11145 int ret;
11146
06a64a0b 11147 exp_valid_block = NULL;
a1442452 11148 val = value_addr (result);
06a64a0b
TT
11149 release_value (val);
11150 value_free_to_mark (mark);
9c06b0b4
TJB
11151
11152 if (use_mask)
11153 {
11154 ret = target_masked_watch_num_registers (value_as_address (val),
11155 mask);
11156 if (ret == -1)
11157 error (_("This target does not support masked watchpoints."));
11158 else if (ret == -2)
11159 error (_("Invalid mask or memory region."));
11160 }
06a64a0b
TT
11161 }
11162 else if (val != NULL)
fa4727a6 11163 release_value (val);
c906108c 11164
bbc13ae3
KS
11165 tok = skip_spaces_const (arg);
11166 end_tok = skip_to_space_const (tok);
c906108c
SS
11167
11168 toklen = end_tok - tok;
11169 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
11170 {
2d134ed3
PA
11171 struct expression *cond;
11172
60e1c644 11173 innermost_block = NULL;
c906108c 11174 tok = cond_start = end_tok + 1;
1bb9788d 11175 cond = parse_exp_1 (&tok, 0, 0, 0);
60e1c644
PA
11176
11177 /* The watchpoint expression may not be local, but the condition
11178 may still be. E.g.: `watch global if local > 0'. */
11179 cond_exp_valid_block = innermost_block;
11180
2d134ed3 11181 xfree (cond);
c906108c
SS
11182 cond_end = tok;
11183 }
11184 if (*tok)
8a3fe4f8 11185 error (_("Junk at end of command."));
c906108c 11186
d983da9c 11187 frame = block_innermost_frame (exp_valid_block);
d983da9c
DJ
11188
11189 /* If the expression is "local", then set up a "watchpoint scope"
11190 breakpoint at the point where we've left the scope of the watchpoint
11191 expression. Create the scope breakpoint before the watchpoint, so
11192 that we will encounter it first in bpstat_stop_status. */
60e1c644 11193 if (exp_valid_block && frame)
d983da9c 11194 {
edb3359d
DJ
11195 if (frame_id_p (frame_unwind_caller_id (frame)))
11196 {
11197 scope_breakpoint
a6d9a66e
UW
11198 = create_internal_breakpoint (frame_unwind_caller_arch (frame),
11199 frame_unwind_caller_pc (frame),
06edf0c0
PA
11200 bp_watchpoint_scope,
11201 &momentary_breakpoint_ops);
d983da9c 11202
edb3359d 11203 scope_breakpoint->enable_state = bp_enabled;
d983da9c 11204
edb3359d
DJ
11205 /* Automatically delete the breakpoint when it hits. */
11206 scope_breakpoint->disposition = disp_del;
d983da9c 11207
edb3359d
DJ
11208 /* Only break in the proper frame (help with recursion). */
11209 scope_breakpoint->frame_id = frame_unwind_caller_id (frame);
d983da9c 11210
edb3359d 11211 /* Set the address at which we will stop. */
a6d9a66e
UW
11212 scope_breakpoint->loc->gdbarch
11213 = frame_unwind_caller_arch (frame);
edb3359d
DJ
11214 scope_breakpoint->loc->requested_address
11215 = frame_unwind_caller_pc (frame);
11216 scope_breakpoint->loc->address
a6d9a66e
UW
11217 = adjust_breakpoint_address (scope_breakpoint->loc->gdbarch,
11218 scope_breakpoint->loc->requested_address,
edb3359d
DJ
11219 scope_breakpoint->type);
11220 }
d983da9c
DJ
11221 }
11222
e8369a73
AB
11223 /* Now set up the breakpoint. We create all watchpoints as hardware
11224 watchpoints here even if hardware watchpoints are turned off, a call
11225 to update_watchpoint later in this function will cause the type to
11226 drop back to bp_watchpoint (software watchpoint) if required. */
11227
11228 if (accessflag == hw_read)
11229 bp_type = bp_read_watchpoint;
11230 else if (accessflag == hw_access)
11231 bp_type = bp_access_watchpoint;
11232 else
11233 bp_type = bp_hardware_watchpoint;
3a5c3e22
PA
11234
11235 w = XCNEW (struct watchpoint);
11236 b = &w->base;
348d480f 11237 if (use_mask)
3a5c3e22
PA
11238 init_raw_breakpoint_without_location (b, NULL, bp_type,
11239 &masked_watchpoint_breakpoint_ops);
348d480f 11240 else
3a5c3e22
PA
11241 init_raw_breakpoint_without_location (b, NULL, bp_type,
11242 &watchpoint_breakpoint_ops);
37e4754d 11243 b->thread = thread;
b5de0fa7 11244 b->disposition = disp_donttouch;
348d480f 11245 b->pspace = current_program_space;
3a5c3e22
PA
11246 w->exp = exp;
11247 w->exp_valid_block = exp_valid_block;
11248 w->cond_exp_valid_block = cond_exp_valid_block;
06a64a0b
TT
11249 if (just_location)
11250 {
11251 struct type *t = value_type (val);
11252 CORE_ADDR addr = value_as_address (val);
11253 char *name;
11254
11255 t = check_typedef (TYPE_TARGET_TYPE (check_typedef (t)));
11256 name = type_to_string (t);
11257
3a5c3e22 11258 w->exp_string_reparse = xstrprintf ("* (%s *) %s", name,
d63d0675 11259 core_addr_to_string (addr));
06a64a0b
TT
11260 xfree (name);
11261
3a5c3e22 11262 w->exp_string = xstrprintf ("-location %.*s",
d63d0675
JK
11263 (int) (exp_end - exp_start), exp_start);
11264
06a64a0b
TT
11265 /* The above expression is in C. */
11266 b->language = language_c;
11267 }
11268 else
3a5c3e22 11269 w->exp_string = savestring (exp_start, exp_end - exp_start);
9c06b0b4
TJB
11270
11271 if (use_mask)
11272 {
3a5c3e22 11273 w->hw_wp_mask = mask;
9c06b0b4
TJB
11274 }
11275 else
11276 {
3a5c3e22 11277 w->val = val;
bb9d5f81
PP
11278 w->val_bitpos = saved_bitpos;
11279 w->val_bitsize = saved_bitsize;
3a5c3e22 11280 w->val_valid = 1;
9c06b0b4 11281 }
77b06cd7 11282
c906108c
SS
11283 if (cond_start)
11284 b->cond_string = savestring (cond_start, cond_end - cond_start);
11285 else
11286 b->cond_string = 0;
c5aa993b 11287
c906108c 11288 if (frame)
f6bc2008 11289 {
3a5c3e22
PA
11290 w->watchpoint_frame = get_frame_id (frame);
11291 w->watchpoint_thread = inferior_ptid;
f6bc2008 11292 }
c906108c 11293 else
f6bc2008 11294 {
3a5c3e22
PA
11295 w->watchpoint_frame = null_frame_id;
11296 w->watchpoint_thread = null_ptid;
f6bc2008 11297 }
c906108c 11298
d983da9c 11299 if (scope_breakpoint != NULL)
c906108c 11300 {
d983da9c
DJ
11301 /* The scope breakpoint is related to the watchpoint. We will
11302 need to act on them together. */
11303 b->related_breakpoint = scope_breakpoint;
11304 scope_breakpoint->related_breakpoint = b;
c906108c 11305 }
d983da9c 11306
06a64a0b
TT
11307 if (!just_location)
11308 value_free_to_mark (mark);
2d134ed3 11309
492d29ea 11310 TRY
a9634178
TJB
11311 {
11312 /* Finally update the new watchpoint. This creates the locations
11313 that should be inserted. */
3a5c3e22 11314 update_watchpoint (w, 1);
a9634178 11315 }
492d29ea 11316 CATCH (e, RETURN_MASK_ALL)
a9634178
TJB
11317 {
11318 delete_breakpoint (b);
11319 throw_exception (e);
11320 }
492d29ea 11321 END_CATCH
a9634178 11322
3ea46bff 11323 install_breakpoint (internal, b, 1);
bbc13ae3 11324 do_cleanups (back_to);
c906108c
SS
11325}
11326
e09342b5 11327/* Return count of debug registers needed to watch the given expression.
e09342b5 11328 If the watchpoint cannot be handled in hardware return zero. */
c906108c 11329
c906108c 11330static int
a9634178 11331can_use_hardware_watchpoint (struct value *v)
c906108c
SS
11332{
11333 int found_memory_cnt = 0;
2e70b7b9 11334 struct value *head = v;
c906108c
SS
11335
11336 /* Did the user specifically forbid us to use hardware watchpoints? */
c5aa993b 11337 if (!can_use_hw_watchpoints)
c906108c 11338 return 0;
c5aa993b 11339
5c44784c
JM
11340 /* Make sure that the value of the expression depends only upon
11341 memory contents, and values computed from them within GDB. If we
11342 find any register references or function calls, we can't use a
11343 hardware watchpoint.
11344
11345 The idea here is that evaluating an expression generates a series
11346 of values, one holding the value of every subexpression. (The
11347 expression a*b+c has five subexpressions: a, b, a*b, c, and
11348 a*b+c.) GDB's values hold almost enough information to establish
11349 the criteria given above --- they identify memory lvalues,
11350 register lvalues, computed values, etcetera. So we can evaluate
11351 the expression, and then scan the chain of values that leaves
11352 behind to decide whether we can detect any possible change to the
11353 expression's final value using only hardware watchpoints.
11354
11355 However, I don't think that the values returned by inferior
11356 function calls are special in any way. So this function may not
11357 notice that an expression involving an inferior function call
11358 can't be watched with hardware watchpoints. FIXME. */
17cf0ecd 11359 for (; v; v = value_next (v))
c906108c 11360 {
5c44784c 11361 if (VALUE_LVAL (v) == lval_memory)
c906108c 11362 {
8464be76
DJ
11363 if (v != head && value_lazy (v))
11364 /* A lazy memory lvalue in the chain is one that GDB never
11365 needed to fetch; we either just used its address (e.g.,
11366 `a' in `a.b') or we never needed it at all (e.g., `a'
11367 in `a,b'). This doesn't apply to HEAD; if that is
11368 lazy then it was not readable, but watch it anyway. */
5c44784c 11369 ;
53a5351d 11370 else
5c44784c
JM
11371 {
11372 /* Ahh, memory we actually used! Check if we can cover
11373 it with hardware watchpoints. */
df407dfe 11374 struct type *vtype = check_typedef (value_type (v));
2e70b7b9
MS
11375
11376 /* We only watch structs and arrays if user asked for it
11377 explicitly, never if they just happen to appear in a
11378 middle of some value chain. */
11379 if (v == head
11380 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
11381 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
11382 {
42ae5230 11383 CORE_ADDR vaddr = value_address (v);
e09342b5
TJB
11384 int len;
11385 int num_regs;
11386
a9634178 11387 len = (target_exact_watchpoints
e09342b5
TJB
11388 && is_scalar_type_recursive (vtype))?
11389 1 : TYPE_LENGTH (value_type (v));
2e70b7b9 11390
e09342b5
TJB
11391 num_regs = target_region_ok_for_hw_watchpoint (vaddr, len);
11392 if (!num_regs)
2e70b7b9
MS
11393 return 0;
11394 else
e09342b5 11395 found_memory_cnt += num_regs;
2e70b7b9 11396 }
5c44784c 11397 }
c5aa993b 11398 }
5086187c
AC
11399 else if (VALUE_LVAL (v) != not_lval
11400 && deprecated_value_modifiable (v) == 0)
38b6c3b3 11401 return 0; /* These are values from the history (e.g., $1). */
5086187c 11402 else if (VALUE_LVAL (v) == lval_register)
38b6c3b3 11403 return 0; /* Cannot watch a register with a HW watchpoint. */
c906108c
SS
11404 }
11405
11406 /* The expression itself looks suitable for using a hardware
11407 watchpoint, but give the target machine a chance to reject it. */
11408 return found_memory_cnt;
11409}
11410
8b93c638 11411void
84f4c1fe 11412watch_command_wrapper (char *arg, int from_tty, int internal)
8b93c638 11413{
84f4c1fe 11414 watch_command_1 (arg, hw_write, from_tty, 0, internal);
06a64a0b
TT
11415}
11416
06a64a0b
TT
11417/* A helper function that looks for the "-location" argument and then
11418 calls watch_command_1. */
11419
11420static void
11421watch_maybe_just_location (char *arg, int accessflag, int from_tty)
11422{
11423 int just_location = 0;
11424
11425 if (arg
11426 && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
11427 || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
11428 {
e9cafbcc 11429 arg = skip_spaces (arg);
06a64a0b
TT
11430 just_location = 1;
11431 }
11432
84f4c1fe 11433 watch_command_1 (arg, accessflag, from_tty, just_location, 0);
8b93c638 11434}
8926118c 11435
c5aa993b 11436static void
fba45db2 11437watch_command (char *arg, int from_tty)
c906108c 11438{
06a64a0b 11439 watch_maybe_just_location (arg, hw_write, from_tty);
c906108c
SS
11440}
11441
8b93c638 11442void
84f4c1fe 11443rwatch_command_wrapper (char *arg, int from_tty, int internal)
8b93c638 11444{
84f4c1fe 11445 watch_command_1 (arg, hw_read, from_tty, 0, internal);
8b93c638 11446}
8926118c 11447
c5aa993b 11448static void
fba45db2 11449rwatch_command (char *arg, int from_tty)
c906108c 11450{
06a64a0b 11451 watch_maybe_just_location (arg, hw_read, from_tty);
c906108c
SS
11452}
11453
8b93c638 11454void
84f4c1fe 11455awatch_command_wrapper (char *arg, int from_tty, int internal)
8b93c638 11456{
84f4c1fe 11457 watch_command_1 (arg, hw_access, from_tty, 0, internal);
8b93c638 11458}
8926118c 11459
c5aa993b 11460static void
fba45db2 11461awatch_command (char *arg, int from_tty)
c906108c 11462{
06a64a0b 11463 watch_maybe_just_location (arg, hw_access, from_tty);
c906108c 11464}
c906108c 11465\f
c5aa993b 11466
43ff13b4 11467/* Helper routines for the until_command routine in infcmd.c. Here
c906108c
SS
11468 because it uses the mechanisms of breakpoints. */
11469
bfec99b2
PA
11470struct until_break_command_continuation_args
11471{
11472 struct breakpoint *breakpoint;
11473 struct breakpoint *breakpoint2;
186c406b 11474 int thread_num;
bfec99b2
PA
11475};
11476
43ff13b4 11477/* This function is called by fetch_inferior_event via the
4a64f543 11478 cmd_continuation pointer, to complete the until command. It takes
43ff13b4 11479 care of cleaning up the temporary breakpoints set up by the until
4a64f543 11480 command. */
c2c6d25f 11481static void
fa4cd53f 11482until_break_command_continuation (void *arg, int err)
43ff13b4 11483{
bfec99b2
PA
11484 struct until_break_command_continuation_args *a = arg;
11485
11486 delete_breakpoint (a->breakpoint);
11487 if (a->breakpoint2)
11488 delete_breakpoint (a->breakpoint2);
186c406b 11489 delete_longjmp_breakpoint (a->thread_num);
43ff13b4
JM
11490}
11491
c906108c 11492void
ae66c1fc 11493until_break_command (char *arg, int from_tty, int anywhere)
c906108c
SS
11494{
11495 struct symtabs_and_lines sals;
11496 struct symtab_and_line sal;
8556afb4
PA
11497 struct frame_info *frame;
11498 struct gdbarch *frame_gdbarch;
11499 struct frame_id stack_frame_id;
11500 struct frame_id caller_frame_id;
c906108c 11501 struct breakpoint *breakpoint;
f107f563 11502 struct breakpoint *breakpoint2 = NULL;
f00aae0f 11503 struct cleanup *old_chain, *cleanup;
186c406b
TT
11504 int thread;
11505 struct thread_info *tp;
f00aae0f 11506 struct event_location *location;
c906108c 11507
70509625 11508 clear_proceed_status (0);
c906108c
SS
11509
11510 /* Set a breakpoint where the user wants it and at return from
4a64f543 11511 this function. */
c5aa993b 11512
f00aae0f
KS
11513 location = string_to_event_location (&arg, current_language);
11514 cleanup = make_cleanup_delete_event_location (location);
11515
1bfeeb0f 11516 if (last_displayed_sal_is_valid ())
f00aae0f 11517 sals = decode_line_1 (location, DECODE_LINE_FUNFIRSTLINE,
1bfeeb0f 11518 get_last_displayed_symtab (),
f8eba3c6 11519 get_last_displayed_line ());
c906108c 11520 else
f00aae0f 11521 sals = decode_line_1 (location, DECODE_LINE_FUNFIRSTLINE,
f8eba3c6 11522 (struct symtab *) NULL, 0);
c5aa993b 11523
c906108c 11524 if (sals.nelts != 1)
8a3fe4f8 11525 error (_("Couldn't get information on specified line."));
c5aa993b 11526
c906108c 11527 sal = sals.sals[0];
4a64f543 11528 xfree (sals.sals); /* malloc'd, so freed. */
c5aa993b 11529
c906108c 11530 if (*arg)
8a3fe4f8 11531 error (_("Junk at end of arguments."));
c5aa993b 11532
c906108c 11533 resolve_sal_pc (&sal);
c5aa993b 11534
186c406b
TT
11535 tp = inferior_thread ();
11536 thread = tp->num;
11537
883bc8d1
PA
11538 old_chain = make_cleanup (null_cleanup, NULL);
11539
8556afb4
PA
11540 /* Note linespec handling above invalidates the frame chain.
11541 Installing a breakpoint also invalidates the frame chain (as it
11542 may need to switch threads), so do any frame handling before
11543 that. */
11544
11545 frame = get_selected_frame (NULL);
11546 frame_gdbarch = get_frame_arch (frame);
11547 stack_frame_id = get_stack_frame_id (frame);
11548 caller_frame_id = frame_unwind_caller_id (frame);
883bc8d1 11549
ae66c1fc
EZ
11550 /* Keep within the current frame, or in frames called by the current
11551 one. */
edb3359d 11552
883bc8d1 11553 if (frame_id_p (caller_frame_id))
c906108c 11554 {
883bc8d1
PA
11555 struct symtab_and_line sal2;
11556
11557 sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
11558 sal2.pc = frame_unwind_caller_pc (frame);
a6d9a66e 11559 breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
883bc8d1
PA
11560 sal2,
11561 caller_frame_id,
f107f563
VP
11562 bp_until);
11563 make_cleanup_delete_breakpoint (breakpoint2);
186c406b 11564
883bc8d1 11565 set_longjmp_breakpoint (tp, caller_frame_id);
186c406b 11566 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
c906108c 11567 }
c5aa993b 11568
c70a6932
JK
11569 /* set_momentary_breakpoint could invalidate FRAME. */
11570 frame = NULL;
11571
883bc8d1
PA
11572 if (anywhere)
11573 /* If the user told us to continue until a specified location,
11574 we don't specify a frame at which we need to stop. */
11575 breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11576 null_frame_id, bp_until);
11577 else
11578 /* Otherwise, specify the selected frame, because we want to stop
11579 only at the very same frame. */
11580 breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
11581 stack_frame_id, bp_until);
11582 make_cleanup_delete_breakpoint (breakpoint);
11583
64ce06e4 11584 proceed (-1, GDB_SIGNAL_DEFAULT);
f107f563 11585
4a64f543
MS
11586 /* If we are running asynchronously, and proceed call above has
11587 actually managed to start the target, arrange for breakpoints to
11588 be deleted when the target stops. Otherwise, we're already
11589 stopped and delete breakpoints via cleanup chain. */
f107f563 11590
8ea051c5 11591 if (target_can_async_p () && is_running (inferior_ptid))
f107f563 11592 {
8d749320
SM
11593 struct until_break_command_continuation_args *args =
11594 XNEW (struct until_break_command_continuation_args);
f107f563 11595
bfec99b2
PA
11596 args->breakpoint = breakpoint;
11597 args->breakpoint2 = breakpoint2;
186c406b 11598 args->thread_num = thread;
f107f563
VP
11599
11600 discard_cleanups (old_chain);
95e54da7
PA
11601 add_continuation (inferior_thread (),
11602 until_break_command_continuation, args,
604ead4a 11603 xfree);
f107f563
VP
11604 }
11605 else
c5aa993b 11606 do_cleanups (old_chain);
f00aae0f
KS
11607
11608 do_cleanups (cleanup);
c906108c 11609}
ae66c1fc 11610
c906108c
SS
11611/* This function attempts to parse an optional "if <cond>" clause
11612 from the arg string. If one is not found, it returns NULL.
c5aa993b 11613
c906108c
SS
11614 Else, it returns a pointer to the condition string. (It does not
11615 attempt to evaluate the string against a particular block.) And,
11616 it updates arg to point to the first character following the parsed
4a64f543 11617 if clause in the arg string. */
53a5351d 11618
916703c0 11619char *
fba45db2 11620ep_parse_optional_if_clause (char **arg)
c906108c 11621{
c5aa993b
JM
11622 char *cond_string;
11623
11624 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
c906108c 11625 return NULL;
c5aa993b 11626
4a64f543 11627 /* Skip the "if" keyword. */
c906108c 11628 (*arg) += 2;
c5aa993b 11629
c906108c 11630 /* Skip any extra leading whitespace, and record the start of the
4a64f543 11631 condition string. */
e9cafbcc 11632 *arg = skip_spaces (*arg);
c906108c 11633 cond_string = *arg;
c5aa993b 11634
4a64f543
MS
11635 /* Assume that the condition occupies the remainder of the arg
11636 string. */
c906108c 11637 (*arg) += strlen (cond_string);
c5aa993b 11638
c906108c
SS
11639 return cond_string;
11640}
c5aa993b 11641
c906108c
SS
11642/* Commands to deal with catching events, such as signals, exceptions,
11643 process start/exit, etc. */
c5aa993b
JM
11644
11645typedef enum
11646{
44feb3ce
TT
11647 catch_fork_temporary, catch_vfork_temporary,
11648 catch_fork_permanent, catch_vfork_permanent
c5aa993b
JM
11649}
11650catch_fork_kind;
11651
c906108c 11652static void
cc59ec59
MS
11653catch_fork_command_1 (char *arg, int from_tty,
11654 struct cmd_list_element *command)
c906108c 11655{
a6d9a66e 11656 struct gdbarch *gdbarch = get_current_arch ();
c5aa993b 11657 char *cond_string = NULL;
44feb3ce
TT
11658 catch_fork_kind fork_kind;
11659 int tempflag;
11660
11661 fork_kind = (catch_fork_kind) (uintptr_t) get_cmd_context (command);
11662 tempflag = (fork_kind == catch_fork_temporary
11663 || fork_kind == catch_vfork_temporary);
c5aa993b 11664
44feb3ce
TT
11665 if (!arg)
11666 arg = "";
e9cafbcc 11667 arg = skip_spaces (arg);
c5aa993b 11668
c906108c 11669 /* The allowed syntax is:
c5aa993b
JM
11670 catch [v]fork
11671 catch [v]fork if <cond>
11672
4a64f543 11673 First, check if there's an if clause. */
c906108c 11674 cond_string = ep_parse_optional_if_clause (&arg);
c5aa993b 11675
c906108c 11676 if ((*arg != '\0') && !isspace (*arg))
8a3fe4f8 11677 error (_("Junk at end of arguments."));
c5aa993b 11678
c906108c 11679 /* If this target supports it, create a fork or vfork catchpoint
4a64f543 11680 and enable reporting of such events. */
c5aa993b
JM
11681 switch (fork_kind)
11682 {
44feb3ce
TT
11683 case catch_fork_temporary:
11684 case catch_fork_permanent:
a6d9a66e 11685 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
ce78b96d 11686 &catch_fork_breakpoint_ops);
c906108c 11687 break;
44feb3ce
TT
11688 case catch_vfork_temporary:
11689 case catch_vfork_permanent:
a6d9a66e 11690 create_fork_vfork_event_catchpoint (gdbarch, tempflag, cond_string,
ce78b96d 11691 &catch_vfork_breakpoint_ops);
c906108c 11692 break;
c5aa993b 11693 default:
8a3fe4f8 11694 error (_("unsupported or unknown fork kind; cannot catch it"));
c906108c 11695 break;
c5aa993b 11696 }
c906108c
SS
11697}
11698
11699static void
cc59ec59
MS
11700catch_exec_command_1 (char *arg, int from_tty,
11701 struct cmd_list_element *command)
c906108c 11702{
b4d90040 11703 struct exec_catchpoint *c;
a6d9a66e 11704 struct gdbarch *gdbarch = get_current_arch ();
44feb3ce 11705 int tempflag;
c5aa993b 11706 char *cond_string = NULL;
c906108c 11707
44feb3ce
TT
11708 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
11709
11710 if (!arg)
11711 arg = "";
e9cafbcc 11712 arg = skip_spaces (arg);
c906108c
SS
11713
11714 /* The allowed syntax is:
c5aa993b
JM
11715 catch exec
11716 catch exec if <cond>
c906108c 11717
4a64f543 11718 First, check if there's an if clause. */
c906108c
SS
11719 cond_string = ep_parse_optional_if_clause (&arg);
11720
11721 if ((*arg != '\0') && !isspace (*arg))
8a3fe4f8 11722 error (_("Junk at end of arguments."));
c906108c 11723
b4d90040
PA
11724 c = XNEW (struct exec_catchpoint);
11725 init_catchpoint (&c->base, gdbarch, tempflag, cond_string,
11726 &catch_exec_breakpoint_ops);
11727 c->exec_pathname = NULL;
11728
3ea46bff 11729 install_breakpoint (0, &c->base, 1);
c906108c 11730}
c5aa993b 11731
9ac4176b 11732void
28010a5d
PA
11733init_ada_exception_breakpoint (struct breakpoint *b,
11734 struct gdbarch *gdbarch,
11735 struct symtab_and_line sal,
11736 char *addr_string,
c0a91b2b 11737 const struct breakpoint_ops *ops,
28010a5d 11738 int tempflag,
349774ef 11739 int enabled,
28010a5d 11740 int from_tty)
f7f9143b 11741{
f7f9143b
JB
11742 if (from_tty)
11743 {
5af949e3
UW
11744 struct gdbarch *loc_gdbarch = get_sal_arch (sal);
11745 if (!loc_gdbarch)
11746 loc_gdbarch = gdbarch;
11747
6c95b8df
PA
11748 describe_other_breakpoints (loc_gdbarch,
11749 sal.pspace, sal.pc, sal.section, -1);
f7f9143b
JB
11750 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11751 version for exception catchpoints, because two catchpoints
11752 used for different exception names will use the same address.
11753 In this case, a "breakpoint ... also set at..." warning is
4a64f543 11754 unproductive. Besides, the warning phrasing is also a bit
e5dd4106 11755 inappropriate, we should use the word catchpoint, and tell
f7f9143b
JB
11756 the user what type of catchpoint it is. The above is good
11757 enough for now, though. */
11758 }
11759
28010a5d 11760 init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
f7f9143b 11761
349774ef 11762 b->enable_state = enabled ? bp_enabled : bp_disabled;
f7f9143b 11763 b->disposition = tempflag ? disp_del : disp_donttouch;
f00aae0f
KS
11764 b->location = string_to_event_location (&addr_string,
11765 language_def (language_ada));
f7f9143b 11766 b->language = language_ada;
f7f9143b
JB
11767}
11768
c906108c 11769static void
fba45db2 11770catch_command (char *arg, int from_tty)
c906108c 11771{
44feb3ce 11772 error (_("Catch requires an event name."));
c906108c
SS
11773}
11774\f
11775
11776static void
fba45db2 11777tcatch_command (char *arg, int from_tty)
c906108c 11778{
44feb3ce 11779 error (_("Catch requires an event name."));
c906108c
SS
11780}
11781
8a2c437b
TT
11782/* A qsort comparison function that sorts breakpoints in order. */
11783
11784static int
11785compare_breakpoints (const void *a, const void *b)
11786{
11787 const breakpoint_p *ba = a;
11788 uintptr_t ua = (uintptr_t) *ba;
11789 const breakpoint_p *bb = b;
11790 uintptr_t ub = (uintptr_t) *bb;
11791
11792 if ((*ba)->number < (*bb)->number)
11793 return -1;
11794 else if ((*ba)->number > (*bb)->number)
11795 return 1;
11796
11797 /* Now sort by address, in case we see, e..g, two breakpoints with
11798 the number 0. */
11799 if (ua < ub)
11800 return -1;
94b0e70d 11801 return ua > ub ? 1 : 0;
8a2c437b
TT
11802}
11803
80f8a6eb 11804/* Delete breakpoints by address or line. */
c906108c
SS
11805
11806static void
fba45db2 11807clear_command (char *arg, int from_tty)
c906108c 11808{
8a2c437b 11809 struct breakpoint *b, *prev;
d6e956e5
VP
11810 VEC(breakpoint_p) *found = 0;
11811 int ix;
c906108c
SS
11812 int default_match;
11813 struct symtabs_and_lines sals;
11814 struct symtab_and_line sal;
c906108c 11815 int i;
8a2c437b 11816 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
c906108c
SS
11817
11818 if (arg)
11819 {
39cf75f7
DE
11820 sals = decode_line_with_current_source (arg,
11821 (DECODE_LINE_FUNFIRSTLINE
11822 | DECODE_LINE_LIST_MODE));
cf4ded82 11823 make_cleanup (xfree, sals.sals);
c906108c
SS
11824 default_match = 0;
11825 }
11826 else
11827 {
8d749320 11828 sals.sals = XNEW (struct symtab_and_line);
80f8a6eb 11829 make_cleanup (xfree, sals.sals);
4a64f543 11830 init_sal (&sal); /* Initialize to zeroes. */
1bfeeb0f
JL
11831
11832 /* Set sal's line, symtab, pc, and pspace to the values
11833 corresponding to the last call to print_frame_info. If the
11834 codepoint is not valid, this will set all the fields to 0. */
11835 get_last_displayed_sal (&sal);
c906108c 11836 if (sal.symtab == 0)
8a3fe4f8 11837 error (_("No source file specified."));
c906108c
SS
11838
11839 sals.sals[0] = sal;
11840 sals.nelts = 1;
11841
11842 default_match = 1;
11843 }
11844
4a64f543
MS
11845 /* We don't call resolve_sal_pc here. That's not as bad as it
11846 seems, because all existing breakpoints typically have both
11847 file/line and pc set. So, if clear is given file/line, we can
11848 match this to existing breakpoint without obtaining pc at all.
ed0616c6
VP
11849
11850 We only support clearing given the address explicitly
11851 present in breakpoint table. Say, we've set breakpoint
4a64f543 11852 at file:line. There were several PC values for that file:line,
ed0616c6 11853 due to optimization, all in one block.
4a64f543
MS
11854
11855 We've picked one PC value. If "clear" is issued with another
ed0616c6
VP
11856 PC corresponding to the same file:line, the breakpoint won't
11857 be cleared. We probably can still clear the breakpoint, but
11858 since the other PC value is never presented to user, user
11859 can only find it by guessing, and it does not seem important
11860 to support that. */
11861
4a64f543
MS
11862 /* For each line spec given, delete bps which correspond to it. Do
11863 it in two passes, solely to preserve the current behavior that
11864 from_tty is forced true if we delete more than one
11865 breakpoint. */
c906108c 11866
80f8a6eb 11867 found = NULL;
8a2c437b 11868 make_cleanup (VEC_cleanup (breakpoint_p), &found);
c906108c
SS
11869 for (i = 0; i < sals.nelts; i++)
11870 {
05cba821
JK
11871 const char *sal_fullname;
11872
c906108c 11873 /* If exact pc given, clear bpts at that pc.
c5aa993b
JM
11874 If line given (pc == 0), clear all bpts on specified line.
11875 If defaulting, clear all bpts on default line
c906108c 11876 or at default pc.
c5aa993b
JM
11877
11878 defaulting sal.pc != 0 tests to do
11879
11880 0 1 pc
11881 1 1 pc _and_ line
11882 0 0 line
11883 1 0 <can't happen> */
c906108c
SS
11884
11885 sal = sals.sals[i];
05cba821
JK
11886 sal_fullname = (sal.symtab == NULL
11887 ? NULL : symtab_to_fullname (sal.symtab));
c906108c 11888
4a64f543 11889 /* Find all matching breakpoints and add them to 'found'. */
d6e956e5 11890 ALL_BREAKPOINTS (b)
c5aa993b 11891 {
0d381245 11892 int match = 0;
4a64f543 11893 /* Are we going to delete b? */
cc60f2e3 11894 if (b->type != bp_none && !is_watchpoint (b))
0d381245
VP
11895 {
11896 struct bp_location *loc = b->loc;
11897 for (; loc; loc = loc->next)
11898 {
f8eba3c6
TT
11899 /* If the user specified file:line, don't allow a PC
11900 match. This matches historical gdb behavior. */
11901 int pc_match = (!sal.explicit_line
11902 && sal.pc
11903 && (loc->pspace == sal.pspace)
11904 && (loc->address == sal.pc)
11905 && (!section_is_overlay (loc->section)
11906 || loc->section == sal.section));
4aac40c8
TT
11907 int line_match = 0;
11908
11909 if ((default_match || sal.explicit_line)
2f202fde 11910 && loc->symtab != NULL
05cba821 11911 && sal_fullname != NULL
4aac40c8 11912 && sal.pspace == loc->pspace
05cba821
JK
11913 && loc->line_number == sal.line
11914 && filename_cmp (symtab_to_fullname (loc->symtab),
11915 sal_fullname) == 0)
11916 line_match = 1;
4aac40c8 11917
0d381245
VP
11918 if (pc_match || line_match)
11919 {
11920 match = 1;
11921 break;
11922 }
11923 }
11924 }
11925
11926 if (match)
d6e956e5 11927 VEC_safe_push(breakpoint_p, found, b);
c906108c 11928 }
80f8a6eb 11929 }
8a2c437b 11930
80f8a6eb 11931 /* Now go thru the 'found' chain and delete them. */
d6e956e5 11932 if (VEC_empty(breakpoint_p, found))
80f8a6eb
MS
11933 {
11934 if (arg)
8a3fe4f8 11935 error (_("No breakpoint at %s."), arg);
80f8a6eb 11936 else
8a3fe4f8 11937 error (_("No breakpoint at this line."));
80f8a6eb 11938 }
c906108c 11939
8a2c437b
TT
11940 /* Remove duplicates from the vec. */
11941 qsort (VEC_address (breakpoint_p, found),
11942 VEC_length (breakpoint_p, found),
11943 sizeof (breakpoint_p),
11944 compare_breakpoints);
11945 prev = VEC_index (breakpoint_p, found, 0);
11946 for (ix = 1; VEC_iterate (breakpoint_p, found, ix, b); ++ix)
11947 {
11948 if (b == prev)
11949 {
11950 VEC_ordered_remove (breakpoint_p, found, ix);
11951 --ix;
11952 }
11953 }
11954
d6e956e5 11955 if (VEC_length(breakpoint_p, found) > 1)
4a64f543 11956 from_tty = 1; /* Always report if deleted more than one. */
80f8a6eb 11957 if (from_tty)
a3f17187 11958 {
d6e956e5 11959 if (VEC_length(breakpoint_p, found) == 1)
a3f17187
AC
11960 printf_unfiltered (_("Deleted breakpoint "));
11961 else
11962 printf_unfiltered (_("Deleted breakpoints "));
11963 }
d6e956e5
VP
11964
11965 for (ix = 0; VEC_iterate(breakpoint_p, found, ix, b); ix++)
80f8a6eb 11966 {
c5aa993b 11967 if (from_tty)
d6e956e5
VP
11968 printf_unfiltered ("%d ", b->number);
11969 delete_breakpoint (b);
c906108c 11970 }
80f8a6eb
MS
11971 if (from_tty)
11972 putchar_unfiltered ('\n');
8a2c437b
TT
11973
11974 do_cleanups (cleanups);
c906108c
SS
11975}
11976\f
11977/* Delete breakpoint in BS if they are `delete' breakpoints and
11978 all breakpoints that are marked for deletion, whether hit or not.
11979 This is called after any breakpoint is hit, or after errors. */
11980
11981void
fba45db2 11982breakpoint_auto_delete (bpstat bs)
c906108c 11983{
35df4500 11984 struct breakpoint *b, *b_tmp;
c906108c
SS
11985
11986 for (; bs; bs = bs->next)
f431efe5
PA
11987 if (bs->breakpoint_at
11988 && bs->breakpoint_at->disposition == disp_del
c906108c 11989 && bs->stop)
f431efe5 11990 delete_breakpoint (bs->breakpoint_at);
c906108c 11991
35df4500 11992 ALL_BREAKPOINTS_SAFE (b, b_tmp)
c5aa993b 11993 {
b5de0fa7 11994 if (b->disposition == disp_del_at_next_stop)
c5aa993b
JM
11995 delete_breakpoint (b);
11996 }
c906108c
SS
11997}
11998
4a64f543
MS
11999/* A comparison function for bp_location AP and BP being interfaced to
12000 qsort. Sort elements primarily by their ADDRESS (no matter what
12001 does breakpoint_address_is_meaningful say for its OWNER),
1a853c52 12002 secondarily by ordering first permanent elements and
4a64f543 12003 terciarily just ensuring the array is sorted stable way despite
e5dd4106 12004 qsort being an unstable algorithm. */
876fa593
JK
12005
12006static int
494cfb0f 12007bp_location_compare (const void *ap, const void *bp)
876fa593 12008{
494cfb0f
JK
12009 struct bp_location *a = *(void **) ap;
12010 struct bp_location *b = *(void **) bp;
876fa593
JK
12011
12012 if (a->address != b->address)
12013 return (a->address > b->address) - (a->address < b->address);
12014
dea2aa5f
LM
12015 /* Sort locations at the same address by their pspace number, keeping
12016 locations of the same inferior (in a multi-inferior environment)
12017 grouped. */
12018
12019 if (a->pspace->num != b->pspace->num)
12020 return ((a->pspace->num > b->pspace->num)
12021 - (a->pspace->num < b->pspace->num));
12022
876fa593 12023 /* Sort permanent breakpoints first. */
1a853c52
PA
12024 if (a->permanent != b->permanent)
12025 return (a->permanent < b->permanent) - (a->permanent > b->permanent);
876fa593 12026
c56a97f9
JK
12027 /* Make the internal GDB representation stable across GDB runs
12028 where A and B memory inside GDB can differ. Breakpoint locations of
12029 the same type at the same address can be sorted in arbitrary order. */
876fa593
JK
12030
12031 if (a->owner->number != b->owner->number)
c56a97f9
JK
12032 return ((a->owner->number > b->owner->number)
12033 - (a->owner->number < b->owner->number));
876fa593
JK
12034
12035 return (a > b) - (a < b);
12036}
12037
876fa593 12038/* Set bp_location_placed_address_before_address_max and
4a64f543
MS
12039 bp_location_shadow_len_after_address_max according to the current
12040 content of the bp_location array. */
f7545552
TT
12041
12042static void
876fa593 12043bp_location_target_extensions_update (void)
f7545552 12044{
876fa593
JK
12045 struct bp_location *bl, **blp_tmp;
12046
12047 bp_location_placed_address_before_address_max = 0;
12048 bp_location_shadow_len_after_address_max = 0;
12049
12050 ALL_BP_LOCATIONS (bl, blp_tmp)
12051 {
12052 CORE_ADDR start, end, addr;
12053
12054 if (!bp_location_has_shadow (bl))
12055 continue;
12056
12057 start = bl->target_info.placed_address;
12058 end = start + bl->target_info.shadow_len;
12059
12060 gdb_assert (bl->address >= start);
12061 addr = bl->address - start;
12062 if (addr > bp_location_placed_address_before_address_max)
12063 bp_location_placed_address_before_address_max = addr;
12064
12065 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
12066
12067 gdb_assert (bl->address < end);
12068 addr = end - bl->address;
12069 if (addr > bp_location_shadow_len_after_address_max)
12070 bp_location_shadow_len_after_address_max = addr;
12071 }
f7545552
TT
12072}
12073
1e4d1764
YQ
12074/* Download tracepoint locations if they haven't been. */
12075
12076static void
12077download_tracepoint_locations (void)
12078{
7ed2c994 12079 struct breakpoint *b;
1e4d1764
YQ
12080 struct cleanup *old_chain;
12081
12082 if (!target_can_download_tracepoint ())
12083 return;
12084
12085 old_chain = save_current_space_and_thread ();
12086
7ed2c994 12087 ALL_TRACEPOINTS (b)
1e4d1764 12088 {
7ed2c994 12089 struct bp_location *bl;
1e4d1764 12090 struct tracepoint *t;
f2a8bc8a 12091 int bp_location_downloaded = 0;
1e4d1764 12092
7ed2c994 12093 if ((b->type == bp_fast_tracepoint
1e4d1764
YQ
12094 ? !may_insert_fast_tracepoints
12095 : !may_insert_tracepoints))
12096 continue;
12097
7ed2c994
YQ
12098 for (bl = b->loc; bl; bl = bl->next)
12099 {
12100 /* In tracepoint, locations are _never_ duplicated, so
12101 should_be_inserted is equivalent to
12102 unduplicated_should_be_inserted. */
12103 if (!should_be_inserted (bl) || bl->inserted)
12104 continue;
1e4d1764 12105
7ed2c994 12106 switch_to_program_space_and_thread (bl->pspace);
1e4d1764 12107
7ed2c994 12108 target_download_tracepoint (bl);
1e4d1764 12109
7ed2c994 12110 bl->inserted = 1;
f2a8bc8a 12111 bp_location_downloaded = 1;
7ed2c994
YQ
12112 }
12113 t = (struct tracepoint *) b;
12114 t->number_on_target = b->number;
f2a8bc8a
YQ
12115 if (bp_location_downloaded)
12116 observer_notify_breakpoint_modified (b);
1e4d1764
YQ
12117 }
12118
12119 do_cleanups (old_chain);
12120}
12121
934709f0
PW
12122/* Swap the insertion/duplication state between two locations. */
12123
12124static void
12125swap_insertion (struct bp_location *left, struct bp_location *right)
12126{
12127 const int left_inserted = left->inserted;
12128 const int left_duplicate = left->duplicate;
b775012e 12129 const int left_needs_update = left->needs_update;
934709f0
PW
12130 const struct bp_target_info left_target_info = left->target_info;
12131
1e4d1764
YQ
12132 /* Locations of tracepoints can never be duplicated. */
12133 if (is_tracepoint (left->owner))
12134 gdb_assert (!left->duplicate);
12135 if (is_tracepoint (right->owner))
12136 gdb_assert (!right->duplicate);
12137
934709f0
PW
12138 left->inserted = right->inserted;
12139 left->duplicate = right->duplicate;
b775012e 12140 left->needs_update = right->needs_update;
934709f0
PW
12141 left->target_info = right->target_info;
12142 right->inserted = left_inserted;
12143 right->duplicate = left_duplicate;
b775012e 12144 right->needs_update = left_needs_update;
934709f0
PW
12145 right->target_info = left_target_info;
12146}
12147
b775012e
LM
12148/* Force the re-insertion of the locations at ADDRESS. This is called
12149 once a new/deleted/modified duplicate location is found and we are evaluating
12150 conditions on the target's side. Such conditions need to be updated on
12151 the target. */
12152
12153static void
12154force_breakpoint_reinsertion (struct bp_location *bl)
12155{
12156 struct bp_location **locp = NULL, **loc2p;
12157 struct bp_location *loc;
12158 CORE_ADDR address = 0;
12159 int pspace_num;
12160
12161 address = bl->address;
12162 pspace_num = bl->pspace->num;
12163
12164 /* This is only meaningful if the target is
12165 evaluating conditions and if the user has
12166 opted for condition evaluation on the target's
12167 side. */
12168 if (gdb_evaluates_breakpoint_condition_p ()
12169 || !target_supports_evaluation_of_breakpoint_conditions ())
12170 return;
12171
12172 /* Flag all breakpoint locations with this address and
12173 the same program space as the location
12174 as "its condition has changed". We need to
12175 update the conditions on the target's side. */
12176 ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
12177 {
12178 loc = *loc2p;
12179
12180 if (!is_breakpoint (loc->owner)
12181 || pspace_num != loc->pspace->num)
12182 continue;
12183
12184 /* Flag the location appropriately. We use a different state to
12185 let everyone know that we already updated the set of locations
12186 with addr bl->address and program space bl->pspace. This is so
12187 we don't have to keep calling these functions just to mark locations
12188 that have already been marked. */
12189 loc->condition_changed = condition_updated;
12190
12191 /* Free the agent expression bytecode as well. We will compute
12192 it later on. */
12193 if (loc->cond_bytecode)
12194 {
12195 free_agent_expr (loc->cond_bytecode);
12196 loc->cond_bytecode = NULL;
12197 }
12198 }
12199}
44702360
PA
12200/* Called whether new breakpoints are created, or existing breakpoints
12201 deleted, to update the global location list and recompute which
12202 locations are duplicate of which.
b775012e 12203
04086b45
PA
12204 The INSERT_MODE flag determines whether locations may not, may, or
12205 shall be inserted now. See 'enum ugll_insert_mode' for more
12206 info. */
b60e7edf 12207
0d381245 12208static void
44702360 12209update_global_location_list (enum ugll_insert_mode insert_mode)
0d381245 12210{
74960c60 12211 struct breakpoint *b;
876fa593 12212 struct bp_location **locp, *loc;
f7545552 12213 struct cleanup *cleanups;
b775012e
LM
12214 /* Last breakpoint location address that was marked for update. */
12215 CORE_ADDR last_addr = 0;
12216 /* Last breakpoint location program space that was marked for update. */
12217 int last_pspace_num = -1;
f7545552 12218
2d134ed3
PA
12219 /* Used in the duplicates detection below. When iterating over all
12220 bp_locations, points to the first bp_location of a given address.
12221 Breakpoints and watchpoints of different types are never
12222 duplicates of each other. Keep one pointer for each type of
12223 breakpoint/watchpoint, so we only need to loop over all locations
12224 once. */
12225 struct bp_location *bp_loc_first; /* breakpoint */
12226 struct bp_location *wp_loc_first; /* hardware watchpoint */
12227 struct bp_location *awp_loc_first; /* access watchpoint */
12228 struct bp_location *rwp_loc_first; /* read watchpoint */
876fa593 12229
4a64f543
MS
12230 /* Saved former bp_location array which we compare against the newly
12231 built bp_location from the current state of ALL_BREAKPOINTS. */
876fa593
JK
12232 struct bp_location **old_location, **old_locp;
12233 unsigned old_location_count;
12234
12235 old_location = bp_location;
12236 old_location_count = bp_location_count;
12237 bp_location = NULL;
12238 bp_location_count = 0;
12239 cleanups = make_cleanup (xfree, old_location);
0d381245 12240
74960c60 12241 ALL_BREAKPOINTS (b)
876fa593
JK
12242 for (loc = b->loc; loc; loc = loc->next)
12243 bp_location_count++;
12244
8d749320 12245 bp_location = XNEWVEC (struct bp_location *, bp_location_count);
876fa593
JK
12246 locp = bp_location;
12247 ALL_BREAKPOINTS (b)
12248 for (loc = b->loc; loc; loc = loc->next)
12249 *locp++ = loc;
12250 qsort (bp_location, bp_location_count, sizeof (*bp_location),
494cfb0f 12251 bp_location_compare);
876fa593
JK
12252
12253 bp_location_target_extensions_update ();
74960c60 12254
4a64f543
MS
12255 /* Identify bp_location instances that are no longer present in the
12256 new list, and therefore should be freed. Note that it's not
12257 necessary that those locations should be removed from inferior --
12258 if there's another location at the same address (previously
12259 marked as duplicate), we don't need to remove/insert the
12260 location.
876fa593 12261
4a64f543
MS
12262 LOCP is kept in sync with OLD_LOCP, each pointing to the current
12263 and former bp_location array state respectively. */
876fa593
JK
12264
12265 locp = bp_location;
12266 for (old_locp = old_location; old_locp < old_location + old_location_count;
12267 old_locp++)
74960c60 12268 {
876fa593 12269 struct bp_location *old_loc = *old_locp;
c7d46a38 12270 struct bp_location **loc2p;
876fa593 12271
e5dd4106 12272 /* Tells if 'old_loc' is found among the new locations. If
4a64f543 12273 not, we have to free it. */
c7d46a38 12274 int found_object = 0;
20874c92
VP
12275 /* Tells if the location should remain inserted in the target. */
12276 int keep_in_target = 0;
12277 int removed = 0;
876fa593 12278
4a64f543
MS
12279 /* Skip LOCP entries which will definitely never be needed.
12280 Stop either at or being the one matching OLD_LOC. */
876fa593 12281 while (locp < bp_location + bp_location_count
c7d46a38 12282 && (*locp)->address < old_loc->address)
876fa593 12283 locp++;
c7d46a38
PA
12284
12285 for (loc2p = locp;
12286 (loc2p < bp_location + bp_location_count
12287 && (*loc2p)->address == old_loc->address);
12288 loc2p++)
12289 {
b775012e
LM
12290 /* Check if this is a new/duplicated location or a duplicated
12291 location that had its condition modified. If so, we want to send
12292 its condition to the target if evaluation of conditions is taking
12293 place there. */
12294 if ((*loc2p)->condition_changed == condition_modified
12295 && (last_addr != old_loc->address
12296 || last_pspace_num != old_loc->pspace->num))
c7d46a38 12297 {
b775012e
LM
12298 force_breakpoint_reinsertion (*loc2p);
12299 last_pspace_num = old_loc->pspace->num;
c7d46a38 12300 }
b775012e
LM
12301
12302 if (*loc2p == old_loc)
12303 found_object = 1;
c7d46a38 12304 }
74960c60 12305
b775012e
LM
12306 /* We have already handled this address, update it so that we don't
12307 have to go through updates again. */
12308 last_addr = old_loc->address;
12309
12310 /* Target-side condition evaluation: Handle deleted locations. */
12311 if (!found_object)
12312 force_breakpoint_reinsertion (old_loc);
12313
4a64f543
MS
12314 /* If this location is no longer present, and inserted, look if
12315 there's maybe a new location at the same address. If so,
12316 mark that one inserted, and don't remove this one. This is
12317 needed so that we don't have a time window where a breakpoint
12318 at certain location is not inserted. */
74960c60 12319
876fa593 12320 if (old_loc->inserted)
0d381245 12321 {
4a64f543
MS
12322 /* If the location is inserted now, we might have to remove
12323 it. */
74960c60 12324
876fa593 12325 if (found_object && should_be_inserted (old_loc))
74960c60 12326 {
4a64f543
MS
12327 /* The location is still present in the location list,
12328 and still should be inserted. Don't do anything. */
20874c92 12329 keep_in_target = 1;
74960c60
VP
12330 }
12331 else
12332 {
b775012e
LM
12333 /* This location still exists, but it won't be kept in the
12334 target since it may have been disabled. We proceed to
12335 remove its target-side condition. */
12336
4a64f543
MS
12337 /* The location is either no longer present, or got
12338 disabled. See if there's another location at the
12339 same address, in which case we don't need to remove
12340 this one from the target. */
876fa593 12341
2bdf28a0 12342 /* OLD_LOC comes from existing struct breakpoint. */
876fa593
JK
12343 if (breakpoint_address_is_meaningful (old_loc->owner))
12344 {
876fa593 12345 for (loc2p = locp;
c7d46a38
PA
12346 (loc2p < bp_location + bp_location_count
12347 && (*loc2p)->address == old_loc->address);
876fa593
JK
12348 loc2p++)
12349 {
12350 struct bp_location *loc2 = *loc2p;
12351
2d134ed3 12352 if (breakpoint_locations_match (loc2, old_loc))
c7d46a38 12353 {
85d721b8
PA
12354 /* Read watchpoint locations are switched to
12355 access watchpoints, if the former are not
12356 supported, but the latter are. */
12357 if (is_hardware_watchpoint (old_loc->owner))
12358 {
12359 gdb_assert (is_hardware_watchpoint (loc2->owner));
12360 loc2->watchpoint_type = old_loc->watchpoint_type;
12361 }
12362
934709f0
PW
12363 /* loc2 is a duplicated location. We need to check
12364 if it should be inserted in case it will be
12365 unduplicated. */
12366 if (loc2 != old_loc
12367 && unduplicated_should_be_inserted (loc2))
c7d46a38 12368 {
934709f0 12369 swap_insertion (old_loc, loc2);
c7d46a38
PA
12370 keep_in_target = 1;
12371 break;
12372 }
876fa593
JK
12373 }
12374 }
12375 }
74960c60
VP
12376 }
12377
20874c92
VP
12378 if (!keep_in_target)
12379 {
876fa593 12380 if (remove_breakpoint (old_loc, mark_uninserted))
20874c92 12381 {
4a64f543
MS
12382 /* This is just about all we can do. We could keep
12383 this location on the global list, and try to
12384 remove it next time, but there's no particular
12385 reason why we will succeed next time.
20874c92 12386
4a64f543
MS
12387 Note that at this point, old_loc->owner is still
12388 valid, as delete_breakpoint frees the breakpoint
12389 only after calling us. */
3e43a32a
MS
12390 printf_filtered (_("warning: Error removing "
12391 "breakpoint %d\n"),
876fa593 12392 old_loc->owner->number);
20874c92
VP
12393 }
12394 removed = 1;
12395 }
0d381245 12396 }
74960c60
VP
12397
12398 if (!found_object)
1c5cfe86 12399 {
fbea99ea 12400 if (removed && target_is_non_stop_p ()
1cf4d951 12401 && need_moribund_for_location_type (old_loc))
20874c92 12402 {
db82e815
PA
12403 /* This location was removed from the target. In
12404 non-stop mode, a race condition is possible where
12405 we've removed a breakpoint, but stop events for that
12406 breakpoint are already queued and will arrive later.
12407 We apply an heuristic to be able to distinguish such
12408 SIGTRAPs from other random SIGTRAPs: we keep this
12409 breakpoint location for a bit, and will retire it
12410 after we see some number of events. The theory here
12411 is that reporting of events should, "on the average",
12412 be fair, so after a while we'll see events from all
12413 threads that have anything of interest, and no longer
12414 need to keep this breakpoint location around. We
12415 don't hold locations forever so to reduce chances of
12416 mistaking a non-breakpoint SIGTRAP for a breakpoint
12417 SIGTRAP.
12418
12419 The heuristic failing can be disastrous on
12420 decr_pc_after_break targets.
12421
12422 On decr_pc_after_break targets, like e.g., x86-linux,
12423 if we fail to recognize a late breakpoint SIGTRAP,
12424 because events_till_retirement has reached 0 too
12425 soon, we'll fail to do the PC adjustment, and report
12426 a random SIGTRAP to the user. When the user resumes
12427 the inferior, it will most likely immediately crash
2dec564e 12428 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
db82e815
PA
12429 corrupted, because of being resumed e.g., in the
12430 middle of a multi-byte instruction, or skipped a
12431 one-byte instruction. This was actually seen happen
12432 on native x86-linux, and should be less rare on
12433 targets that do not support new thread events, like
12434 remote, due to the heuristic depending on
12435 thread_count.
12436
12437 Mistaking a random SIGTRAP for a breakpoint trap
12438 causes similar symptoms (PC adjustment applied when
12439 it shouldn't), but then again, playing with SIGTRAPs
12440 behind the debugger's back is asking for trouble.
12441
12442 Since hardware watchpoint traps are always
12443 distinguishable from other traps, so we don't need to
12444 apply keep hardware watchpoint moribund locations
12445 around. We simply always ignore hardware watchpoint
12446 traps we can no longer explain. */
12447
876fa593
JK
12448 old_loc->events_till_retirement = 3 * (thread_count () + 1);
12449 old_loc->owner = NULL;
20874c92 12450
876fa593 12451 VEC_safe_push (bp_location_p, moribund_locations, old_loc);
1c5cfe86
PA
12452 }
12453 else
f431efe5
PA
12454 {
12455 old_loc->owner = NULL;
12456 decref_bp_location (&old_loc);
12457 }
20874c92 12458 }
74960c60 12459 }
1c5cfe86 12460
348d480f
PA
12461 /* Rescan breakpoints at the same address and section, marking the
12462 first one as "first" and any others as "duplicates". This is so
12463 that the bpt instruction is only inserted once. If we have a
12464 permanent breakpoint at the same place as BPT, make that one the
12465 official one, and the rest as duplicates. Permanent breakpoints
12466 are sorted first for the same address.
12467
12468 Do the same for hardware watchpoints, but also considering the
12469 watchpoint's type (regular/access/read) and length. */
12470
12471 bp_loc_first = NULL;
12472 wp_loc_first = NULL;
12473 awp_loc_first = NULL;
12474 rwp_loc_first = NULL;
12475 ALL_BP_LOCATIONS (loc, locp)
12476 {
12477 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12478 non-NULL. */
348d480f 12479 struct bp_location **loc_first_p;
d3fbdd86 12480 b = loc->owner;
348d480f 12481
6f380991 12482 if (!unduplicated_should_be_inserted (loc)
348d480f 12483 || !breakpoint_address_is_meaningful (b)
1e4d1764
YQ
12484 /* Don't detect duplicate for tracepoint locations because they are
12485 never duplicated. See the comments in field `duplicate' of
12486 `struct bp_location'. */
348d480f 12487 || is_tracepoint (b))
b775012e
LM
12488 {
12489 /* Clear the condition modification flag. */
12490 loc->condition_changed = condition_unchanged;
12491 continue;
12492 }
348d480f 12493
348d480f
PA
12494 if (b->type == bp_hardware_watchpoint)
12495 loc_first_p = &wp_loc_first;
12496 else if (b->type == bp_read_watchpoint)
12497 loc_first_p = &rwp_loc_first;
12498 else if (b->type == bp_access_watchpoint)
12499 loc_first_p = &awp_loc_first;
12500 else
12501 loc_first_p = &bp_loc_first;
12502
12503 if (*loc_first_p == NULL
12504 || (overlay_debugging && loc->section != (*loc_first_p)->section)
12505 || !breakpoint_locations_match (loc, *loc_first_p))
12506 {
12507 *loc_first_p = loc;
12508 loc->duplicate = 0;
b775012e
LM
12509
12510 if (is_breakpoint (loc->owner) && loc->condition_changed)
12511 {
12512 loc->needs_update = 1;
12513 /* Clear the condition modification flag. */
12514 loc->condition_changed = condition_unchanged;
12515 }
348d480f
PA
12516 continue;
12517 }
12518
934709f0
PW
12519
12520 /* This and the above ensure the invariant that the first location
12521 is not duplicated, and is the inserted one.
12522 All following are marked as duplicated, and are not inserted. */
12523 if (loc->inserted)
12524 swap_insertion (loc, *loc_first_p);
348d480f
PA
12525 loc->duplicate = 1;
12526
b775012e
LM
12527 /* Clear the condition modification flag. */
12528 loc->condition_changed = condition_unchanged;
348d480f
PA
12529 }
12530
a25a5a45 12531 if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
b775012e 12532 {
04086b45 12533 if (insert_mode != UGLL_DONT_INSERT)
b775012e
LM
12534 insert_breakpoint_locations ();
12535 else
12536 {
44702360
PA
12537 /* Even though the caller told us to not insert new
12538 locations, we may still need to update conditions on the
12539 target's side of breakpoints that were already inserted
12540 if the target is evaluating breakpoint conditions. We
b775012e
LM
12541 only update conditions for locations that are marked
12542 "needs_update". */
12543 update_inserted_breakpoint_locations ();
12544 }
12545 }
348d480f 12546
04086b45 12547 if (insert_mode != UGLL_DONT_INSERT)
1e4d1764
YQ
12548 download_tracepoint_locations ();
12549
348d480f
PA
12550 do_cleanups (cleanups);
12551}
12552
12553void
12554breakpoint_retire_moribund (void)
12555{
12556 struct bp_location *loc;
12557 int ix;
12558
12559 for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
12560 if (--(loc->events_till_retirement) == 0)
12561 {
12562 decref_bp_location (&loc);
12563 VEC_unordered_remove (bp_location_p, moribund_locations, ix);
12564 --ix;
12565 }
12566}
12567
12568static void
44702360 12569update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
348d480f 12570{
348d480f 12571
492d29ea
PA
12572 TRY
12573 {
12574 update_global_location_list (insert_mode);
12575 }
12576 CATCH (e, RETURN_MASK_ERROR)
12577 {
12578 }
12579 END_CATCH
348d480f
PA
12580}
12581
12582/* Clear BKP from a BPS. */
12583
12584static void
12585bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
12586{
12587 bpstat bs;
12588
12589 for (bs = bps; bs; bs = bs->next)
12590 if (bs->breakpoint_at == bpt)
12591 {
12592 bs->breakpoint_at = NULL;
12593 bs->old_val = NULL;
12594 /* bs->commands will be freed later. */
12595 }
12596}
12597
12598/* Callback for iterate_over_threads. */
12599static int
12600bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
12601{
12602 struct breakpoint *bpt = data;
12603
12604 bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
12605 return 0;
12606}
12607
12608/* Helper for breakpoint and tracepoint breakpoint_ops->mention
12609 callbacks. */
12610
12611static void
12612say_where (struct breakpoint *b)
12613{
12614 struct value_print_options opts;
12615
12616 get_user_print_options (&opts);
12617
12618 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12619 single string. */
12620 if (b->loc == NULL)
12621 {
f00aae0f
KS
12622 /* For pending locations, the output differs slightly based
12623 on b->extra_string. If this is non-NULL, it contains either
12624 a condition or dprintf arguments. */
12625 if (b->extra_string == NULL)
12626 {
12627 printf_filtered (_(" (%s) pending."),
12628 event_location_to_string (b->location));
12629 }
12630 else if (b->type == bp_dprintf)
12631 {
12632 printf_filtered (_(" (%s,%s) pending."),
12633 event_location_to_string (b->location),
12634 b->extra_string);
12635 }
12636 else
12637 {
12638 printf_filtered (_(" (%s %s) pending."),
12639 event_location_to_string (b->location),
12640 b->extra_string);
12641 }
348d480f
PA
12642 }
12643 else
12644 {
2f202fde 12645 if (opts.addressprint || b->loc->symtab == NULL)
348d480f
PA
12646 {
12647 printf_filtered (" at ");
12648 fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
12649 gdb_stdout);
12650 }
2f202fde 12651 if (b->loc->symtab != NULL)
f8eba3c6
TT
12652 {
12653 /* If there is a single location, we can print the location
12654 more nicely. */
12655 if (b->loc->next == NULL)
12656 printf_filtered (": file %s, line %d.",
05cba821
JK
12657 symtab_to_filename_for_display (b->loc->symtab),
12658 b->loc->line_number);
f8eba3c6
TT
12659 else
12660 /* This is not ideal, but each location may have a
12661 different file name, and this at least reflects the
12662 real situation somewhat. */
f00aae0f
KS
12663 printf_filtered (": %s.",
12664 event_location_to_string (b->location));
f8eba3c6 12665 }
348d480f
PA
12666
12667 if (b->loc->next)
12668 {
12669 struct bp_location *loc = b->loc;
12670 int n = 0;
12671 for (; loc; loc = loc->next)
12672 ++n;
12673 printf_filtered (" (%d locations)", n);
12674 }
12675 }
12676}
12677
348d480f
PA
12678/* Default bp_location_ops methods. */
12679
12680static void
12681bp_location_dtor (struct bp_location *self)
12682{
12683 xfree (self->cond);
b775012e
LM
12684 if (self->cond_bytecode)
12685 free_agent_expr (self->cond_bytecode);
348d480f 12686 xfree (self->function_name);
8b4f3082
PA
12687
12688 VEC_free (agent_expr_p, self->target_info.conditions);
12689 VEC_free (agent_expr_p, self->target_info.tcommands);
348d480f
PA
12690}
12691
12692static const struct bp_location_ops bp_location_ops =
12693{
12694 bp_location_dtor
12695};
12696
2060206e
PA
12697/* Default breakpoint_ops methods all breakpoint_ops ultimately
12698 inherit from. */
348d480f 12699
2060206e
PA
12700static void
12701base_breakpoint_dtor (struct breakpoint *self)
348d480f
PA
12702{
12703 decref_counted_command_line (&self->commands);
12704 xfree (self->cond_string);
fb81d016 12705 xfree (self->extra_string);
f8eba3c6 12706 xfree (self->filter);
f00aae0f
KS
12707 delete_event_location (self->location);
12708 delete_event_location (self->location_range_end);
348d480f
PA
12709}
12710
2060206e
PA
12711static struct bp_location *
12712base_breakpoint_allocate_location (struct breakpoint *self)
348d480f
PA
12713{
12714 struct bp_location *loc;
12715
12716 loc = XNEW (struct bp_location);
12717 init_bp_location (loc, &bp_location_ops, self);
12718 return loc;
12719}
12720
2060206e
PA
12721static void
12722base_breakpoint_re_set (struct breakpoint *b)
12723{
12724 /* Nothing to re-set. */
12725}
12726
12727#define internal_error_pure_virtual_called() \
12728 gdb_assert_not_reached ("pure virtual function called")
12729
12730static int
12731base_breakpoint_insert_location (struct bp_location *bl)
12732{
12733 internal_error_pure_virtual_called ();
12734}
12735
12736static int
12737base_breakpoint_remove_location (struct bp_location *bl)
12738{
12739 internal_error_pure_virtual_called ();
12740}
12741
12742static int
12743base_breakpoint_breakpoint_hit (const struct bp_location *bl,
12744 struct address_space *aspace,
09ac7c10
TT
12745 CORE_ADDR bp_addr,
12746 const struct target_waitstatus *ws)
2060206e
PA
12747{
12748 internal_error_pure_virtual_called ();
12749}
12750
12751static void
12752base_breakpoint_check_status (bpstat bs)
12753{
12754 /* Always stop. */
12755}
12756
12757/* A "works_in_software_mode" breakpoint_ops method that just internal
12758 errors. */
12759
12760static int
12761base_breakpoint_works_in_software_mode (const struct breakpoint *b)
12762{
12763 internal_error_pure_virtual_called ();
12764}
12765
12766/* A "resources_needed" breakpoint_ops method that just internal
12767 errors. */
12768
12769static int
12770base_breakpoint_resources_needed (const struct bp_location *bl)
12771{
12772 internal_error_pure_virtual_called ();
12773}
12774
12775static enum print_stop_action
12776base_breakpoint_print_it (bpstat bs)
12777{
12778 internal_error_pure_virtual_called ();
12779}
12780
12781static void
12782base_breakpoint_print_one_detail (const struct breakpoint *self,
12783 struct ui_out *uiout)
12784{
12785 /* nothing */
12786}
12787
12788static void
12789base_breakpoint_print_mention (struct breakpoint *b)
12790{
12791 internal_error_pure_virtual_called ();
12792}
12793
12794static void
12795base_breakpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
12796{
12797 internal_error_pure_virtual_called ();
12798}
12799
983af33b 12800static void
f00aae0f
KS
12801base_breakpoint_create_sals_from_location
12802 (const struct event_location *location,
12803 struct linespec_result *canonical,
12804 enum bptype type_wanted)
983af33b
SDJ
12805{
12806 internal_error_pure_virtual_called ();
12807}
12808
12809static void
12810base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
12811 struct linespec_result *c,
983af33b 12812 char *cond_string,
e7e0cddf 12813 char *extra_string,
983af33b
SDJ
12814 enum bptype type_wanted,
12815 enum bpdisp disposition,
12816 int thread,
12817 int task, int ignore_count,
12818 const struct breakpoint_ops *o,
12819 int from_tty, int enabled,
44f238bb 12820 int internal, unsigned flags)
983af33b
SDJ
12821{
12822 internal_error_pure_virtual_called ();
12823}
12824
12825static void
f00aae0f
KS
12826base_breakpoint_decode_location (struct breakpoint *b,
12827 const struct event_location *location,
983af33b
SDJ
12828 struct symtabs_and_lines *sals)
12829{
12830 internal_error_pure_virtual_called ();
12831}
12832
ab04a2af
TT
12833/* The default 'explains_signal' method. */
12834
47591c29 12835static int
427cd150 12836base_breakpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
ab04a2af 12837{
47591c29 12838 return 1;
ab04a2af
TT
12839}
12840
9d6e6e84
HZ
12841/* The default "after_condition_true" method. */
12842
12843static void
12844base_breakpoint_after_condition_true (struct bpstats *bs)
12845{
12846 /* Nothing to do. */
12847}
12848
ab04a2af 12849struct breakpoint_ops base_breakpoint_ops =
2060206e
PA
12850{
12851 base_breakpoint_dtor,
12852 base_breakpoint_allocate_location,
12853 base_breakpoint_re_set,
12854 base_breakpoint_insert_location,
12855 base_breakpoint_remove_location,
12856 base_breakpoint_breakpoint_hit,
12857 base_breakpoint_check_status,
12858 base_breakpoint_resources_needed,
12859 base_breakpoint_works_in_software_mode,
12860 base_breakpoint_print_it,
12861 NULL,
12862 base_breakpoint_print_one_detail,
12863 base_breakpoint_print_mention,
983af33b 12864 base_breakpoint_print_recreate,
5f700d83 12865 base_breakpoint_create_sals_from_location,
983af33b 12866 base_breakpoint_create_breakpoints_sal,
5f700d83 12867 base_breakpoint_decode_location,
9d6e6e84
HZ
12868 base_breakpoint_explains_signal,
12869 base_breakpoint_after_condition_true,
2060206e
PA
12870};
12871
12872/* Default breakpoint_ops methods. */
12873
12874static void
348d480f
PA
12875bkpt_re_set (struct breakpoint *b)
12876{
06edf0c0 12877 /* FIXME: is this still reachable? */
f00aae0f 12878 if (event_location_empty_p (b->location))
06edf0c0 12879 {
f00aae0f 12880 /* Anything without a location can't be re-set. */
348d480f 12881 delete_breakpoint (b);
06edf0c0 12882 return;
348d480f 12883 }
06edf0c0
PA
12884
12885 breakpoint_re_set_default (b);
348d480f
PA
12886}
12887
2060206e 12888static int
348d480f
PA
12889bkpt_insert_location (struct bp_location *bl)
12890{
12891 if (bl->loc_type == bp_loc_hardware_breakpoint)
7c16b83e 12892 return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
348d480f 12893 else
7c16b83e 12894 return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
348d480f
PA
12895}
12896
2060206e 12897static int
348d480f
PA
12898bkpt_remove_location (struct bp_location *bl)
12899{
12900 if (bl->loc_type == bp_loc_hardware_breakpoint)
12901 return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
12902 else
7c16b83e 12903 return target_remove_breakpoint (bl->gdbarch, &bl->target_info);
348d480f
PA
12904}
12905
2060206e 12906static int
348d480f 12907bkpt_breakpoint_hit (const struct bp_location *bl,
09ac7c10
TT
12908 struct address_space *aspace, CORE_ADDR bp_addr,
12909 const struct target_waitstatus *ws)
348d480f 12910{
09ac7c10 12911 if (ws->kind != TARGET_WAITKIND_STOPPED
a493e3e2 12912 || ws->value.sig != GDB_SIGNAL_TRAP)
09ac7c10
TT
12913 return 0;
12914
348d480f
PA
12915 if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
12916 aspace, bp_addr))
12917 return 0;
12918
12919 if (overlay_debugging /* unmapped overlay section */
12920 && section_is_overlay (bl->section)
12921 && !section_is_mapped (bl->section))
12922 return 0;
12923
12924 return 1;
12925}
12926
cd1608cc
PA
12927static int
12928dprintf_breakpoint_hit (const struct bp_location *bl,
12929 struct address_space *aspace, CORE_ADDR bp_addr,
12930 const struct target_waitstatus *ws)
12931{
12932 if (dprintf_style == dprintf_style_agent
12933 && target_can_run_breakpoint_commands ())
12934 {
12935 /* An agent-style dprintf never causes a stop. If we see a trap
12936 for this address it must be for a breakpoint that happens to
12937 be set at the same address. */
12938 return 0;
12939 }
12940
12941 return bkpt_breakpoint_hit (bl, aspace, bp_addr, ws);
12942}
12943
2060206e 12944static int
348d480f
PA
12945bkpt_resources_needed (const struct bp_location *bl)
12946{
12947 gdb_assert (bl->owner->type == bp_hardware_breakpoint);
12948
12949 return 1;
12950}
12951
2060206e 12952static enum print_stop_action
348d480f
PA
12953bkpt_print_it (bpstat bs)
12954{
348d480f
PA
12955 struct breakpoint *b;
12956 const struct bp_location *bl;
001c8c33 12957 int bp_temp;
79a45e25 12958 struct ui_out *uiout = current_uiout;
348d480f
PA
12959
12960 gdb_assert (bs->bp_location_at != NULL);
12961
12962 bl = bs->bp_location_at;
12963 b = bs->breakpoint_at;
12964
001c8c33
PA
12965 bp_temp = b->disposition == disp_del;
12966 if (bl->address != bl->requested_address)
12967 breakpoint_adjustment_warning (bl->requested_address,
12968 bl->address,
12969 b->number, 1);
12970 annotate_breakpoint (b->number);
12971 if (bp_temp)
12972 ui_out_text (uiout, "\nTemporary breakpoint ");
12973 else
12974 ui_out_text (uiout, "\nBreakpoint ");
12975 if (ui_out_is_mi_like_p (uiout))
348d480f 12976 {
001c8c33
PA
12977 ui_out_field_string (uiout, "reason",
12978 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
12979 ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
06edf0c0 12980 }
001c8c33
PA
12981 ui_out_field_int (uiout, "bkptno", b->number);
12982 ui_out_text (uiout, ", ");
06edf0c0 12983
001c8c33 12984 return PRINT_SRC_AND_LOC;
06edf0c0
PA
12985}
12986
2060206e 12987static void
06edf0c0
PA
12988bkpt_print_mention (struct breakpoint *b)
12989{
79a45e25 12990 if (ui_out_is_mi_like_p (current_uiout))
06edf0c0
PA
12991 return;
12992
12993 switch (b->type)
12994 {
12995 case bp_breakpoint:
12996 case bp_gnu_ifunc_resolver:
12997 if (b->disposition == disp_del)
12998 printf_filtered (_("Temporary breakpoint"));
12999 else
13000 printf_filtered (_("Breakpoint"));
13001 printf_filtered (_(" %d"), b->number);
13002 if (b->type == bp_gnu_ifunc_resolver)
13003 printf_filtered (_(" at gnu-indirect-function resolver"));
13004 break;
13005 case bp_hardware_breakpoint:
13006 printf_filtered (_("Hardware assisted breakpoint %d"), b->number);
13007 break;
e7e0cddf
SS
13008 case bp_dprintf:
13009 printf_filtered (_("Dprintf %d"), b->number);
13010 break;
06edf0c0
PA
13011 }
13012
13013 say_where (b);
13014}
13015
2060206e 13016static void
06edf0c0
PA
13017bkpt_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13018{
13019 if (tp->type == bp_breakpoint && tp->disposition == disp_del)
13020 fprintf_unfiltered (fp, "tbreak");
13021 else if (tp->type == bp_breakpoint)
13022 fprintf_unfiltered (fp, "break");
13023 else if (tp->type == bp_hardware_breakpoint
13024 && tp->disposition == disp_del)
13025 fprintf_unfiltered (fp, "thbreak");
13026 else if (tp->type == bp_hardware_breakpoint)
13027 fprintf_unfiltered (fp, "hbreak");
13028 else
13029 internal_error (__FILE__, __LINE__,
13030 _("unhandled breakpoint type %d"), (int) tp->type);
13031
f00aae0f
KS
13032 fprintf_unfiltered (fp, " %s",
13033 event_location_to_string (tp->location));
13034
13035 /* Print out extra_string if this breakpoint is pending. It might
13036 contain, for example, conditions that were set by the user. */
13037 if (tp->loc == NULL && tp->extra_string != NULL)
13038 fprintf_unfiltered (fp, " %s", tp->extra_string);
13039
dd11a36c 13040 print_recreate_thread (tp, fp);
06edf0c0
PA
13041}
13042
983af33b 13043static void
f00aae0f
KS
13044bkpt_create_sals_from_location (const struct event_location *location,
13045 struct linespec_result *canonical,
13046 enum bptype type_wanted)
983af33b 13047{
f00aae0f 13048 create_sals_from_location_default (location, canonical, type_wanted);
983af33b
SDJ
13049}
13050
13051static void
13052bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
13053 struct linespec_result *canonical,
983af33b 13054 char *cond_string,
e7e0cddf 13055 char *extra_string,
983af33b
SDJ
13056 enum bptype type_wanted,
13057 enum bpdisp disposition,
13058 int thread,
13059 int task, int ignore_count,
13060 const struct breakpoint_ops *ops,
13061 int from_tty, int enabled,
44f238bb 13062 int internal, unsigned flags)
983af33b 13063{
023fa29b 13064 create_breakpoints_sal_default (gdbarch, canonical,
e7e0cddf
SS
13065 cond_string, extra_string,
13066 type_wanted,
983af33b
SDJ
13067 disposition, thread, task,
13068 ignore_count, ops, from_tty,
44f238bb 13069 enabled, internal, flags);
983af33b
SDJ
13070}
13071
13072static void
f00aae0f
KS
13073bkpt_decode_location (struct breakpoint *b,
13074 const struct event_location *location,
983af33b
SDJ
13075 struct symtabs_and_lines *sals)
13076{
f00aae0f 13077 decode_location_default (b, location, sals);
983af33b
SDJ
13078}
13079
06edf0c0
PA
13080/* Virtual table for internal breakpoints. */
13081
13082static void
13083internal_bkpt_re_set (struct breakpoint *b)
13084{
13085 switch (b->type)
13086 {
13087 /* Delete overlay event and longjmp master breakpoints; they
13088 will be reset later by breakpoint_re_set. */
13089 case bp_overlay_event:
13090 case bp_longjmp_master:
13091 case bp_std_terminate_master:
13092 case bp_exception_master:
13093 delete_breakpoint (b);
13094 break;
13095
13096 /* This breakpoint is special, it's set up when the inferior
13097 starts and we really don't want to touch it. */
13098 case bp_shlib_event:
13099
13100 /* Like bp_shlib_event, this breakpoint type is special. Once
13101 it is set up, we do not want to touch it. */
13102 case bp_thread_event:
13103 break;
13104 }
13105}
13106
13107static void
13108internal_bkpt_check_status (bpstat bs)
13109{
a9b3a50f
PA
13110 if (bs->breakpoint_at->type == bp_shlib_event)
13111 {
13112 /* If requested, stop when the dynamic linker notifies GDB of
13113 events. This allows the user to get control and place
13114 breakpoints in initializer routines for dynamically loaded
13115 objects (among other things). */
13116 bs->stop = stop_on_solib_events;
13117 bs->print = stop_on_solib_events;
13118 }
13119 else
13120 bs->stop = 0;
06edf0c0
PA
13121}
13122
13123static enum print_stop_action
13124internal_bkpt_print_it (bpstat bs)
13125{
06edf0c0 13126 struct breakpoint *b;
06edf0c0 13127
06edf0c0
PA
13128 b = bs->breakpoint_at;
13129
06edf0c0
PA
13130 switch (b->type)
13131 {
348d480f
PA
13132 case bp_shlib_event:
13133 /* Did we stop because the user set the stop_on_solib_events
13134 variable? (If so, we report this as a generic, "Stopped due
13135 to shlib event" message.) */
edcc5120 13136 print_solib_event (0);
348d480f
PA
13137 break;
13138
13139 case bp_thread_event:
13140 /* Not sure how we will get here.
13141 GDB should not stop for these breakpoints. */
13142 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
348d480f
PA
13143 break;
13144
13145 case bp_overlay_event:
13146 /* By analogy with the thread event, GDB should not stop for these. */
13147 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
348d480f
PA
13148 break;
13149
13150 case bp_longjmp_master:
13151 /* These should never be enabled. */
13152 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
348d480f
PA
13153 break;
13154
13155 case bp_std_terminate_master:
13156 /* These should never be enabled. */
13157 printf_filtered (_("std::terminate Master Breakpoint: "
13158 "gdb should not stop!\n"));
348d480f
PA
13159 break;
13160
13161 case bp_exception_master:
13162 /* These should never be enabled. */
13163 printf_filtered (_("Exception Master Breakpoint: "
13164 "gdb should not stop!\n"));
06edf0c0
PA
13165 break;
13166 }
13167
001c8c33 13168 return PRINT_NOTHING;
06edf0c0
PA
13169}
13170
13171static void
13172internal_bkpt_print_mention (struct breakpoint *b)
13173{
13174 /* Nothing to mention. These breakpoints are internal. */
13175}
13176
06edf0c0
PA
13177/* Virtual table for momentary breakpoints */
13178
13179static void
13180momentary_bkpt_re_set (struct breakpoint *b)
13181{
13182 /* Keep temporary breakpoints, which can be encountered when we step
4d1eb6b4 13183 over a dlopen call and solib_add is resetting the breakpoints.
06edf0c0
PA
13184 Otherwise these should have been blown away via the cleanup chain
13185 or by breakpoint_init_inferior when we rerun the executable. */
13186}
13187
13188static void
13189momentary_bkpt_check_status (bpstat bs)
13190{
13191 /* Nothing. The point of these breakpoints is causing a stop. */
13192}
13193
13194static enum print_stop_action
13195momentary_bkpt_print_it (bpstat bs)
13196{
79a45e25
PA
13197 struct ui_out *uiout = current_uiout;
13198
001c8c33 13199 if (ui_out_is_mi_like_p (uiout))
06edf0c0 13200 {
001c8c33 13201 struct breakpoint *b = bs->breakpoint_at;
348d480f 13202
001c8c33
PA
13203 switch (b->type)
13204 {
13205 case bp_finish:
13206 ui_out_field_string
13207 (uiout, "reason",
13208 async_reason_lookup (EXEC_ASYNC_FUNCTION_FINISHED));
13209 break;
348d480f 13210
001c8c33
PA
13211 case bp_until:
13212 ui_out_field_string
13213 (uiout, "reason",
13214 async_reason_lookup (EXEC_ASYNC_LOCATION_REACHED));
13215 break;
13216 }
348d480f
PA
13217 }
13218
001c8c33 13219 return PRINT_UNKNOWN;
348d480f
PA
13220}
13221
06edf0c0
PA
13222static void
13223momentary_bkpt_print_mention (struct breakpoint *b)
348d480f 13224{
06edf0c0 13225 /* Nothing to mention. These breakpoints are internal. */
348d480f
PA
13226}
13227
e2e4d78b
JK
13228/* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
13229
13230 It gets cleared already on the removal of the first one of such placed
13231 breakpoints. This is OK as they get all removed altogether. */
13232
13233static void
13234longjmp_bkpt_dtor (struct breakpoint *self)
13235{
13236 struct thread_info *tp = find_thread_id (self->thread);
13237
13238 if (tp)
13239 tp->initiating_frame = null_frame_id;
13240
13241 momentary_breakpoint_ops.dtor (self);
13242}
13243
55aa24fb
SDJ
13244/* Specific methods for probe breakpoints. */
13245
13246static int
13247bkpt_probe_insert_location (struct bp_location *bl)
13248{
13249 int v = bkpt_insert_location (bl);
13250
13251 if (v == 0)
13252 {
13253 /* The insertion was successful, now let's set the probe's semaphore
13254 if needed. */
0ea5cda8
SDJ
13255 if (bl->probe.probe->pops->set_semaphore != NULL)
13256 bl->probe.probe->pops->set_semaphore (bl->probe.probe,
13257 bl->probe.objfile,
13258 bl->gdbarch);
55aa24fb
SDJ
13259 }
13260
13261 return v;
13262}
13263
13264static int
13265bkpt_probe_remove_location (struct bp_location *bl)
13266{
13267 /* Let's clear the semaphore before removing the location. */
0ea5cda8
SDJ
13268 if (bl->probe.probe->pops->clear_semaphore != NULL)
13269 bl->probe.probe->pops->clear_semaphore (bl->probe.probe,
13270 bl->probe.objfile,
13271 bl->gdbarch);
55aa24fb
SDJ
13272
13273 return bkpt_remove_location (bl);
13274}
13275
13276static void
f00aae0f 13277bkpt_probe_create_sals_from_location (const struct event_location *location,
5f700d83 13278 struct linespec_result *canonical,
f00aae0f 13279 enum bptype type_wanted)
55aa24fb
SDJ
13280{
13281 struct linespec_sals lsal;
13282
f00aae0f
KS
13283 lsal.sals = parse_probes (location, canonical);
13284 lsal.canonical = xstrdup (event_location_to_string (canonical->location));
55aa24fb
SDJ
13285 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13286}
13287
13288static void
f00aae0f
KS
13289bkpt_probe_decode_location (struct breakpoint *b,
13290 const struct event_location *location,
55aa24fb
SDJ
13291 struct symtabs_and_lines *sals)
13292{
f00aae0f 13293 *sals = parse_probes (location, NULL);
55aa24fb
SDJ
13294 if (!sals->sals)
13295 error (_("probe not found"));
13296}
13297
348d480f 13298/* The breakpoint_ops structure to be used in tracepoints. */
876fa593 13299
348d480f
PA
13300static void
13301tracepoint_re_set (struct breakpoint *b)
13302{
13303 breakpoint_re_set_default (b);
13304}
876fa593 13305
348d480f
PA
13306static int
13307tracepoint_breakpoint_hit (const struct bp_location *bl,
09ac7c10
TT
13308 struct address_space *aspace, CORE_ADDR bp_addr,
13309 const struct target_waitstatus *ws)
348d480f
PA
13310{
13311 /* By definition, the inferior does not report stops at
13312 tracepoints. */
13313 return 0;
74960c60
VP
13314}
13315
13316static void
348d480f
PA
13317tracepoint_print_one_detail (const struct breakpoint *self,
13318 struct ui_out *uiout)
74960c60 13319{
d9b3f62e
PA
13320 struct tracepoint *tp = (struct tracepoint *) self;
13321 if (tp->static_trace_marker_id)
348d480f
PA
13322 {
13323 gdb_assert (self->type == bp_static_tracepoint);
cc59ec59 13324
348d480f
PA
13325 ui_out_text (uiout, "\tmarker id is ");
13326 ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
d9b3f62e 13327 tp->static_trace_marker_id);
348d480f
PA
13328 ui_out_text (uiout, "\n");
13329 }
0d381245
VP
13330}
13331
a474d7c2 13332static void
348d480f 13333tracepoint_print_mention (struct breakpoint *b)
a474d7c2 13334{
79a45e25 13335 if (ui_out_is_mi_like_p (current_uiout))
348d480f 13336 return;
cc59ec59 13337
348d480f
PA
13338 switch (b->type)
13339 {
13340 case bp_tracepoint:
13341 printf_filtered (_("Tracepoint"));
13342 printf_filtered (_(" %d"), b->number);
13343 break;
13344 case bp_fast_tracepoint:
13345 printf_filtered (_("Fast tracepoint"));
13346 printf_filtered (_(" %d"), b->number);
13347 break;
13348 case bp_static_tracepoint:
13349 printf_filtered (_("Static tracepoint"));
13350 printf_filtered (_(" %d"), b->number);
13351 break;
13352 default:
13353 internal_error (__FILE__, __LINE__,
13354 _("unhandled tracepoint type %d"), (int) b->type);
13355 }
13356
13357 say_where (b);
a474d7c2
PA
13358}
13359
348d480f 13360static void
d9b3f62e 13361tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
a474d7c2 13362{
d9b3f62e
PA
13363 struct tracepoint *tp = (struct tracepoint *) self;
13364
13365 if (self->type == bp_fast_tracepoint)
348d480f 13366 fprintf_unfiltered (fp, "ftrace");
d9b3f62e 13367 if (self->type == bp_static_tracepoint)
348d480f 13368 fprintf_unfiltered (fp, "strace");
d9b3f62e 13369 else if (self->type == bp_tracepoint)
348d480f
PA
13370 fprintf_unfiltered (fp, "trace");
13371 else
13372 internal_error (__FILE__, __LINE__,
d9b3f62e 13373 _("unhandled tracepoint type %d"), (int) self->type);
cc59ec59 13374
f00aae0f
KS
13375 fprintf_unfiltered (fp, " %s",
13376 event_location_to_string (self->location));
d9b3f62e
PA
13377 print_recreate_thread (self, fp);
13378
13379 if (tp->pass_count)
13380 fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
a474d7c2
PA
13381}
13382
983af33b 13383static void
f00aae0f
KS
13384tracepoint_create_sals_from_location (const struct event_location *location,
13385 struct linespec_result *canonical,
13386 enum bptype type_wanted)
983af33b 13387{
f00aae0f 13388 create_sals_from_location_default (location, canonical, type_wanted);
983af33b
SDJ
13389}
13390
13391static void
13392tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
13393 struct linespec_result *canonical,
983af33b 13394 char *cond_string,
e7e0cddf 13395 char *extra_string,
983af33b
SDJ
13396 enum bptype type_wanted,
13397 enum bpdisp disposition,
13398 int thread,
13399 int task, int ignore_count,
13400 const struct breakpoint_ops *ops,
13401 int from_tty, int enabled,
44f238bb 13402 int internal, unsigned flags)
983af33b 13403{
023fa29b 13404 create_breakpoints_sal_default (gdbarch, canonical,
e7e0cddf
SS
13405 cond_string, extra_string,
13406 type_wanted,
983af33b
SDJ
13407 disposition, thread, task,
13408 ignore_count, ops, from_tty,
44f238bb 13409 enabled, internal, flags);
983af33b
SDJ
13410}
13411
13412static void
f00aae0f
KS
13413tracepoint_decode_location (struct breakpoint *b,
13414 const struct event_location *location,
983af33b
SDJ
13415 struct symtabs_and_lines *sals)
13416{
f00aae0f 13417 decode_location_default (b, location, sals);
983af33b
SDJ
13418}
13419
2060206e 13420struct breakpoint_ops tracepoint_breakpoint_ops;
348d480f 13421
55aa24fb
SDJ
13422/* The breakpoint_ops structure to be use on tracepoints placed in a
13423 static probe. */
13424
13425static void
f00aae0f
KS
13426tracepoint_probe_create_sals_from_location
13427 (const struct event_location *location,
13428 struct linespec_result *canonical,
13429 enum bptype type_wanted)
55aa24fb
SDJ
13430{
13431 /* We use the same method for breakpoint on probes. */
f00aae0f 13432 bkpt_probe_create_sals_from_location (location, canonical, type_wanted);
55aa24fb
SDJ
13433}
13434
13435static void
f00aae0f
KS
13436tracepoint_probe_decode_location (struct breakpoint *b,
13437 const struct event_location *location,
55aa24fb
SDJ
13438 struct symtabs_and_lines *sals)
13439{
13440 /* We use the same method for breakpoint on probes. */
f00aae0f 13441 bkpt_probe_decode_location (b, location, sals);
55aa24fb
SDJ
13442}
13443
13444static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
13445
5c2b4418
HZ
13446/* Dprintf breakpoint_ops methods. */
13447
13448static void
13449dprintf_re_set (struct breakpoint *b)
13450{
13451 breakpoint_re_set_default (b);
13452
f00aae0f
KS
13453 /* extra_string should never be non-NULL for dprintf. */
13454 gdb_assert (b->extra_string != NULL);
5c2b4418
HZ
13455
13456 /* 1 - connect to target 1, that can run breakpoint commands.
13457 2 - create a dprintf, which resolves fine.
13458 3 - disconnect from target 1
13459 4 - connect to target 2, that can NOT run breakpoint commands.
13460
13461 After steps #3/#4, you'll want the dprintf command list to
13462 be updated, because target 1 and 2 may well return different
13463 answers for target_can_run_breakpoint_commands().
13464 Given absence of finer grained resetting, we get to do
13465 it all the time. */
13466 if (b->extra_string != NULL)
13467 update_dprintf_command_list (b);
13468}
13469
2d9442cc
HZ
13470/* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13471
13472static void
13473dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp)
13474{
f00aae0f
KS
13475 fprintf_unfiltered (fp, "dprintf %s,%s",
13476 event_location_to_string (tp->location),
2d9442cc
HZ
13477 tp->extra_string);
13478 print_recreate_thread (tp, fp);
13479}
13480
9d6e6e84
HZ
13481/* Implement the "after_condition_true" breakpoint_ops method for
13482 dprintf.
13483
13484 dprintf's are implemented with regular commands in their command
13485 list, but we run the commands here instead of before presenting the
13486 stop to the user, as dprintf's don't actually cause a stop. This
13487 also makes it so that the commands of multiple dprintfs at the same
13488 address are all handled. */
13489
13490static void
13491dprintf_after_condition_true (struct bpstats *bs)
13492{
13493 struct cleanup *old_chain;
13494 struct bpstats tmp_bs = { NULL };
13495 struct bpstats *tmp_bs_p = &tmp_bs;
13496
13497 /* dprintf's never cause a stop. This wasn't set in the
13498 check_status hook instead because that would make the dprintf's
13499 condition not be evaluated. */
13500 bs->stop = 0;
13501
13502 /* Run the command list here. Take ownership of it instead of
13503 copying. We never want these commands to run later in
13504 bpstat_do_actions, if a breakpoint that causes a stop happens to
13505 be set at same address as this dprintf, or even if running the
13506 commands here throws. */
13507 tmp_bs.commands = bs->commands;
13508 bs->commands = NULL;
13509 old_chain = make_cleanup_decref_counted_command_line (&tmp_bs.commands);
13510
13511 bpstat_do_actions_1 (&tmp_bs_p);
13512
13513 /* 'tmp_bs.commands' will usually be NULL by now, but
13514 bpstat_do_actions_1 may return early without processing the whole
13515 list. */
13516 do_cleanups (old_chain);
13517}
13518
983af33b
SDJ
13519/* The breakpoint_ops structure to be used on static tracepoints with
13520 markers (`-m'). */
13521
13522static void
f00aae0f 13523strace_marker_create_sals_from_location (const struct event_location *location,
5f700d83 13524 struct linespec_result *canonical,
f00aae0f 13525 enum bptype type_wanted)
983af33b
SDJ
13526{
13527 struct linespec_sals lsal;
f00aae0f
KS
13528 const char *arg_start, *arg;
13529 char *str;
13530 struct cleanup *cleanup;
983af33b 13531
f00aae0f
KS
13532 arg = arg_start = get_linespec_location (location);
13533 lsal.sals = decode_static_tracepoint_spec (&arg);
983af33b 13534
f00aae0f
KS
13535 str = savestring (arg_start, arg - arg_start);
13536 cleanup = make_cleanup (xfree, str);
13537 canonical->location = new_linespec_location (&str);
13538 do_cleanups (cleanup);
983af33b 13539
f00aae0f 13540 lsal.canonical = xstrdup (event_location_to_string (canonical->location));
983af33b
SDJ
13541 VEC_safe_push (linespec_sals, canonical->sals, &lsal);
13542}
13543
13544static void
13545strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
13546 struct linespec_result *canonical,
983af33b 13547 char *cond_string,
e7e0cddf 13548 char *extra_string,
983af33b
SDJ
13549 enum bptype type_wanted,
13550 enum bpdisp disposition,
13551 int thread,
13552 int task, int ignore_count,
13553 const struct breakpoint_ops *ops,
13554 int from_tty, int enabled,
44f238bb 13555 int internal, unsigned flags)
983af33b
SDJ
13556{
13557 int i;
52d361e1
YQ
13558 struct linespec_sals *lsal = VEC_index (linespec_sals,
13559 canonical->sals, 0);
983af33b
SDJ
13560
13561 /* If the user is creating a static tracepoint by marker id
13562 (strace -m MARKER_ID), then store the sals index, so that
13563 breakpoint_re_set can try to match up which of the newly
13564 found markers corresponds to this one, and, don't try to
13565 expand multiple locations for each sal, given than SALS
13566 already should contain all sals for MARKER_ID. */
13567
13568 for (i = 0; i < lsal->sals.nelts; ++i)
13569 {
13570 struct symtabs_and_lines expanded;
13571 struct tracepoint *tp;
13572 struct cleanup *old_chain;
f00aae0f 13573 struct event_location *location;
983af33b
SDJ
13574
13575 expanded.nelts = 1;
13576 expanded.sals = &lsal->sals.sals[i];
13577
f00aae0f
KS
13578 location = copy_event_location (canonical->location);
13579 old_chain = make_cleanup_delete_event_location (location);
983af33b
SDJ
13580
13581 tp = XCNEW (struct tracepoint);
13582 init_breakpoint_sal (&tp->base, gdbarch, expanded,
f00aae0f 13583 location, NULL,
e7e0cddf
SS
13584 cond_string, extra_string,
13585 type_wanted, disposition,
983af33b 13586 thread, task, ignore_count, ops,
44f238bb 13587 from_tty, enabled, internal, flags,
983af33b
SDJ
13588 canonical->special_display);
13589 /* Given that its possible to have multiple markers with
13590 the same string id, if the user is creating a static
13591 tracepoint by marker id ("strace -m MARKER_ID"), then
13592 store the sals index, so that breakpoint_re_set can
13593 try to match up which of the newly found markers
13594 corresponds to this one */
13595 tp->static_trace_marker_id_idx = i;
13596
13597 install_breakpoint (internal, &tp->base, 0);
13598
13599 discard_cleanups (old_chain);
13600 }
13601}
13602
13603static void
f00aae0f
KS
13604strace_marker_decode_location (struct breakpoint *b,
13605 const struct event_location *location,
983af33b
SDJ
13606 struct symtabs_and_lines *sals)
13607{
13608 struct tracepoint *tp = (struct tracepoint *) b;
f00aae0f 13609 const char *s = get_linespec_location (location);
983af33b 13610
f00aae0f 13611 *sals = decode_static_tracepoint_spec (&s);
983af33b
SDJ
13612 if (sals->nelts > tp->static_trace_marker_id_idx)
13613 {
13614 sals->sals[0] = sals->sals[tp->static_trace_marker_id_idx];
13615 sals->nelts = 1;
13616 }
13617 else
13618 error (_("marker %s not found"), tp->static_trace_marker_id);
13619}
13620
13621static struct breakpoint_ops strace_marker_breakpoint_ops;
13622
13623static int
13624strace_marker_p (struct breakpoint *b)
13625{
13626 return b->ops == &strace_marker_breakpoint_ops;
13627}
13628
53a5351d 13629/* Delete a breakpoint and clean up all traces of it in the data
f431efe5 13630 structures. */
c906108c
SS
13631
13632void
fba45db2 13633delete_breakpoint (struct breakpoint *bpt)
c906108c 13634{
52f0bd74 13635 struct breakpoint *b;
c906108c 13636
8a3fe4f8 13637 gdb_assert (bpt != NULL);
c906108c 13638
4a64f543
MS
13639 /* Has this bp already been deleted? This can happen because
13640 multiple lists can hold pointers to bp's. bpstat lists are
13641 especial culprits.
13642
13643 One example of this happening is a watchpoint's scope bp. When
13644 the scope bp triggers, we notice that the watchpoint is out of
13645 scope, and delete it. We also delete its scope bp. But the
13646 scope bp is marked "auto-deleting", and is already on a bpstat.
13647 That bpstat is then checked for auto-deleting bp's, which are
13648 deleted.
13649
13650 A real solution to this problem might involve reference counts in
13651 bp's, and/or giving them pointers back to their referencing
13652 bpstat's, and teaching delete_breakpoint to only free a bp's
13653 storage when no more references were extent. A cheaper bandaid
13654 was chosen. */
c906108c
SS
13655 if (bpt->type == bp_none)
13656 return;
13657
4a64f543
MS
13658 /* At least avoid this stale reference until the reference counting
13659 of breakpoints gets resolved. */
d0fb5eae 13660 if (bpt->related_breakpoint != bpt)
e5a0a904 13661 {
d0fb5eae 13662 struct breakpoint *related;
3a5c3e22 13663 struct watchpoint *w;
d0fb5eae
JK
13664
13665 if (bpt->type == bp_watchpoint_scope)
3a5c3e22 13666 w = (struct watchpoint *) bpt->related_breakpoint;
d0fb5eae 13667 else if (bpt->related_breakpoint->type == bp_watchpoint_scope)
3a5c3e22
PA
13668 w = (struct watchpoint *) bpt;
13669 else
13670 w = NULL;
13671 if (w != NULL)
13672 watchpoint_del_at_next_stop (w);
d0fb5eae
JK
13673
13674 /* Unlink bpt from the bpt->related_breakpoint ring. */
13675 for (related = bpt; related->related_breakpoint != bpt;
13676 related = related->related_breakpoint);
13677 related->related_breakpoint = bpt->related_breakpoint;
13678 bpt->related_breakpoint = bpt;
e5a0a904
JK
13679 }
13680
a9634178
TJB
13681 /* watch_command_1 creates a watchpoint but only sets its number if
13682 update_watchpoint succeeds in creating its bp_locations. If there's
13683 a problem in that process, we'll be asked to delete the half-created
13684 watchpoint. In that case, don't announce the deletion. */
13685 if (bpt->number)
13686 observer_notify_breakpoint_deleted (bpt);
c906108c 13687
c906108c
SS
13688 if (breakpoint_chain == bpt)
13689 breakpoint_chain = bpt->next;
13690
c906108c
SS
13691 ALL_BREAKPOINTS (b)
13692 if (b->next == bpt)
c5aa993b
JM
13693 {
13694 b->next = bpt->next;
13695 break;
13696 }
c906108c 13697
f431efe5
PA
13698 /* Be sure no bpstat's are pointing at the breakpoint after it's
13699 been freed. */
13700 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
e5dd4106 13701 in all threads for now. Note that we cannot just remove bpstats
f431efe5
PA
13702 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13703 commands are associated with the bpstat; if we remove it here,
13704 then the later call to bpstat_do_actions (&stop_bpstat); in
13705 event-top.c won't do anything, and temporary breakpoints with
13706 commands won't work. */
13707
13708 iterate_over_threads (bpstat_remove_breakpoint_callback, bpt);
13709
4a64f543
MS
13710 /* Now that breakpoint is removed from breakpoint list, update the
13711 global location list. This will remove locations that used to
13712 belong to this breakpoint. Do this before freeing the breakpoint
13713 itself, since remove_breakpoint looks at location's owner. It
13714 might be better design to have location completely
13715 self-contained, but it's not the case now. */
44702360 13716 update_global_location_list (UGLL_DONT_INSERT);
74960c60 13717
348d480f 13718 bpt->ops->dtor (bpt);
4a64f543
MS
13719 /* On the chance that someone will soon try again to delete this
13720 same bp, we mark it as deleted before freeing its storage. */
c906108c 13721 bpt->type = bp_none;
b8c9b27d 13722 xfree (bpt);
c906108c
SS
13723}
13724
4d6140d9
AC
13725static void
13726do_delete_breakpoint_cleanup (void *b)
13727{
13728 delete_breakpoint (b);
13729}
13730
13731struct cleanup *
13732make_cleanup_delete_breakpoint (struct breakpoint *b)
13733{
13734 return make_cleanup (do_delete_breakpoint_cleanup, b);
13735}
13736
51be5b68
PA
13737/* Iterator function to call a user-provided callback function once
13738 for each of B and its related breakpoints. */
13739
13740static void
13741iterate_over_related_breakpoints (struct breakpoint *b,
13742 void (*function) (struct breakpoint *,
13743 void *),
13744 void *data)
13745{
13746 struct breakpoint *related;
13747
13748 related = b;
13749 do
13750 {
13751 struct breakpoint *next;
13752
13753 /* FUNCTION may delete RELATED. */
13754 next = related->related_breakpoint;
13755
13756 if (next == related)
13757 {
13758 /* RELATED is the last ring entry. */
13759 function (related, data);
13760
13761 /* FUNCTION may have deleted it, so we'd never reach back to
13762 B. There's nothing left to do anyway, so just break
13763 out. */
13764 break;
13765 }
13766 else
13767 function (related, data);
13768
13769 related = next;
13770 }
13771 while (related != b);
13772}
95a42b64
TT
13773
13774static void
13775do_delete_breakpoint (struct breakpoint *b, void *ignore)
13776{
13777 delete_breakpoint (b);
13778}
13779
51be5b68
PA
13780/* A callback for map_breakpoint_numbers that calls
13781 delete_breakpoint. */
13782
13783static void
13784do_map_delete_breakpoint (struct breakpoint *b, void *ignore)
13785{
13786 iterate_over_related_breakpoints (b, do_delete_breakpoint, NULL);
13787}
13788
c906108c 13789void
fba45db2 13790delete_command (char *arg, int from_tty)
c906108c 13791{
35df4500 13792 struct breakpoint *b, *b_tmp;
c906108c 13793
ea9365bb
TT
13794 dont_repeat ();
13795
c906108c
SS
13796 if (arg == 0)
13797 {
13798 int breaks_to_delete = 0;
13799
46c6471b
PA
13800 /* Delete all breakpoints if no argument. Do not delete
13801 internal breakpoints, these have to be deleted with an
13802 explicit breakpoint number argument. */
c5aa993b 13803 ALL_BREAKPOINTS (b)
46c6471b 13804 if (user_breakpoint_p (b))
973d738b
DJ
13805 {
13806 breaks_to_delete = 1;
13807 break;
13808 }
c906108c
SS
13809
13810 /* Ask user only if there are some breakpoints to delete. */
13811 if (!from_tty
e2e0b3e5 13812 || (breaks_to_delete && query (_("Delete all breakpoints? "))))
c906108c 13813 {
35df4500 13814 ALL_BREAKPOINTS_SAFE (b, b_tmp)
46c6471b 13815 if (user_breakpoint_p (b))
c5aa993b 13816 delete_breakpoint (b);
c906108c
SS
13817 }
13818 }
13819 else
51be5b68 13820 map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
c906108c
SS
13821}
13822
0d381245
VP
13823static int
13824all_locations_are_pending (struct bp_location *loc)
fe3f5fa8 13825{
0d381245 13826 for (; loc; loc = loc->next)
8645ff69
UW
13827 if (!loc->shlib_disabled
13828 && !loc->pspace->executing_startup)
0d381245
VP
13829 return 0;
13830 return 1;
fe3f5fa8
VP
13831}
13832
776592bf
DE
13833/* Subroutine of update_breakpoint_locations to simplify it.
13834 Return non-zero if multiple fns in list LOC have the same name.
13835 Null names are ignored. */
13836
13837static int
13838ambiguous_names_p (struct bp_location *loc)
13839{
13840 struct bp_location *l;
13841 htab_t htab = htab_create_alloc (13, htab_hash_string,
cc59ec59
MS
13842 (int (*) (const void *,
13843 const void *)) streq,
776592bf
DE
13844 NULL, xcalloc, xfree);
13845
13846 for (l = loc; l != NULL; l = l->next)
13847 {
13848 const char **slot;
13849 const char *name = l->function_name;
13850
13851 /* Allow for some names to be NULL, ignore them. */
13852 if (name == NULL)
13853 continue;
13854
13855 slot = (const char **) htab_find_slot (htab, (const void *) name,
13856 INSERT);
4a64f543
MS
13857 /* NOTE: We can assume slot != NULL here because xcalloc never
13858 returns NULL. */
776592bf
DE
13859 if (*slot != NULL)
13860 {
13861 htab_delete (htab);
13862 return 1;
13863 }
13864 *slot = name;
13865 }
13866
13867 htab_delete (htab);
13868 return 0;
13869}
13870
0fb4aa4b
PA
13871/* When symbols change, it probably means the sources changed as well,
13872 and it might mean the static tracepoint markers are no longer at
13873 the same address or line numbers they used to be at last we
13874 checked. Losing your static tracepoints whenever you rebuild is
13875 undesirable. This function tries to resync/rematch gdb static
13876 tracepoints with the markers on the target, for static tracepoints
13877 that have not been set by marker id. Static tracepoint that have
13878 been set by marker id are reset by marker id in breakpoint_re_set.
13879 The heuristic is:
13880
13881 1) For a tracepoint set at a specific address, look for a marker at
13882 the old PC. If one is found there, assume to be the same marker.
13883 If the name / string id of the marker found is different from the
13884 previous known name, assume that means the user renamed the marker
13885 in the sources, and output a warning.
13886
13887 2) For a tracepoint set at a given line number, look for a marker
13888 at the new address of the old line number. If one is found there,
13889 assume to be the same marker. If the name / string id of the
13890 marker found is different from the previous known name, assume that
13891 means the user renamed the marker in the sources, and output a
13892 warning.
13893
13894 3) If a marker is no longer found at the same address or line, it
13895 may mean the marker no longer exists. But it may also just mean
13896 the code changed a bit. Maybe the user added a few lines of code
13897 that made the marker move up or down (in line number terms). Ask
13898 the target for info about the marker with the string id as we knew
13899 it. If found, update line number and address in the matching
13900 static tracepoint. This will get confused if there's more than one
13901 marker with the same ID (possible in UST, although unadvised
13902 precisely because it confuses tools). */
13903
13904static struct symtab_and_line
13905update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
13906{
d9b3f62e 13907 struct tracepoint *tp = (struct tracepoint *) b;
0fb4aa4b
PA
13908 struct static_tracepoint_marker marker;
13909 CORE_ADDR pc;
0fb4aa4b
PA
13910
13911 pc = sal.pc;
13912 if (sal.line)
13913 find_line_pc (sal.symtab, sal.line, &pc);
13914
13915 if (target_static_tracepoint_marker_at (pc, &marker))
13916 {
d9b3f62e 13917 if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
0fb4aa4b
PA
13918 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13919 b->number,
d9b3f62e 13920 tp->static_trace_marker_id, marker.str_id);
0fb4aa4b 13921
d9b3f62e
PA
13922 xfree (tp->static_trace_marker_id);
13923 tp->static_trace_marker_id = xstrdup (marker.str_id);
0fb4aa4b
PA
13924 release_static_tracepoint_marker (&marker);
13925
13926 return sal;
13927 }
13928
13929 /* Old marker wasn't found on target at lineno. Try looking it up
13930 by string ID. */
13931 if (!sal.explicit_pc
13932 && sal.line != 0
13933 && sal.symtab != NULL
d9b3f62e 13934 && tp->static_trace_marker_id != NULL)
0fb4aa4b
PA
13935 {
13936 VEC(static_tracepoint_marker_p) *markers;
13937
13938 markers
d9b3f62e 13939 = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
0fb4aa4b
PA
13940
13941 if (!VEC_empty(static_tracepoint_marker_p, markers))
13942 {
80e1d417 13943 struct symtab_and_line sal2;
0fb4aa4b 13944 struct symbol *sym;
80e1d417 13945 struct static_tracepoint_marker *tpmarker;
79a45e25 13946 struct ui_out *uiout = current_uiout;
67994074 13947 struct explicit_location explicit_loc;
0fb4aa4b 13948
80e1d417 13949 tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
0fb4aa4b 13950
d9b3f62e 13951 xfree (tp->static_trace_marker_id);
80e1d417 13952 tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
0fb4aa4b
PA
13953
13954 warning (_("marker for static tracepoint %d (%s) not "
13955 "found at previous line number"),
d9b3f62e 13956 b->number, tp->static_trace_marker_id);
0fb4aa4b 13957
80e1d417 13958 init_sal (&sal2);
0fb4aa4b 13959
80e1d417 13960 sal2.pc = tpmarker->address;
0fb4aa4b 13961
80e1d417
AS
13962 sal2 = find_pc_line (tpmarker->address, 0);
13963 sym = find_pc_sect_function (tpmarker->address, NULL);
0fb4aa4b
PA
13964 ui_out_text (uiout, "Now in ");
13965 if (sym)
13966 {
13967 ui_out_field_string (uiout, "func",
13968 SYMBOL_PRINT_NAME (sym));
13969 ui_out_text (uiout, " at ");
13970 }
05cba821
JK
13971 ui_out_field_string (uiout, "file",
13972 symtab_to_filename_for_display (sal2.symtab));
0fb4aa4b
PA
13973 ui_out_text (uiout, ":");
13974
13975 if (ui_out_is_mi_like_p (uiout))
13976 {
0b0865da 13977 const char *fullname = symtab_to_fullname (sal2.symtab);
0fb4aa4b 13978
f35a17b5 13979 ui_out_field_string (uiout, "fullname", fullname);
0fb4aa4b
PA
13980 }
13981
80e1d417 13982 ui_out_field_int (uiout, "line", sal2.line);
0fb4aa4b
PA
13983 ui_out_text (uiout, "\n");
13984
80e1d417 13985 b->loc->line_number = sal2.line;
2f202fde 13986 b->loc->symtab = sym != NULL ? sal2.symtab : NULL;
0fb4aa4b 13987
f00aae0f 13988 delete_event_location (b->location);
67994074
KS
13989 initialize_explicit_location (&explicit_loc);
13990 explicit_loc.source_filename
00e52e53 13991 = ASTRDUP (symtab_to_filename_for_display (sal2.symtab));
67994074
KS
13992 explicit_loc.line_offset.offset = b->loc->line_number;
13993 explicit_loc.line_offset.sign = LINE_OFFSET_NONE;
13994 b->location = new_explicit_location (&explicit_loc);
0fb4aa4b
PA
13995
13996 /* Might be nice to check if function changed, and warn if
13997 so. */
13998
80e1d417 13999 release_static_tracepoint_marker (tpmarker);
0fb4aa4b
PA
14000 }
14001 }
14002 return sal;
14003}
14004
8d3788bd
VP
14005/* Returns 1 iff locations A and B are sufficiently same that
14006 we don't need to report breakpoint as changed. */
14007
14008static int
14009locations_are_equal (struct bp_location *a, struct bp_location *b)
14010{
14011 while (a && b)
14012 {
14013 if (a->address != b->address)
14014 return 0;
14015
14016 if (a->shlib_disabled != b->shlib_disabled)
14017 return 0;
14018
14019 if (a->enabled != b->enabled)
14020 return 0;
14021
14022 a = a->next;
14023 b = b->next;
14024 }
14025
14026 if ((a == NULL) != (b == NULL))
14027 return 0;
14028
14029 return 1;
14030}
14031
f1310107
TJB
14032/* Create new breakpoint locations for B (a hardware or software breakpoint)
14033 based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
14034 a ranged breakpoint. */
14035
0e30163f 14036void
0d381245 14037update_breakpoint_locations (struct breakpoint *b,
f1310107
TJB
14038 struct symtabs_and_lines sals,
14039 struct symtabs_and_lines sals_end)
fe3f5fa8
VP
14040{
14041 int i;
0d381245
VP
14042 struct bp_location *existing_locations = b->loc;
14043
f8eba3c6
TT
14044 if (sals_end.nelts != 0 && (sals.nelts != 1 || sals_end.nelts != 1))
14045 {
14046 /* Ranged breakpoints have only one start location and one end
14047 location. */
14048 b->enable_state = bp_disabled;
44702360 14049 update_global_location_list (UGLL_MAY_INSERT);
f8eba3c6
TT
14050 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
14051 "multiple locations found\n"),
14052 b->number);
14053 return;
14054 }
f1310107 14055
4a64f543
MS
14056 /* If there's no new locations, and all existing locations are
14057 pending, don't do anything. This optimizes the common case where
14058 all locations are in the same shared library, that was unloaded.
14059 We'd like to retain the location, so that when the library is
14060 loaded again, we don't loose the enabled/disabled status of the
14061 individual locations. */
0d381245 14062 if (all_locations_are_pending (existing_locations) && sals.nelts == 0)
fe3f5fa8
VP
14063 return;
14064
fe3f5fa8
VP
14065 b->loc = NULL;
14066
0d381245 14067 for (i = 0; i < sals.nelts; ++i)
fe3f5fa8 14068 {
f8eba3c6
TT
14069 struct bp_location *new_loc;
14070
14071 switch_to_program_space_and_thread (sals.sals[i].pspace);
14072
14073 new_loc = add_location_to_breakpoint (b, &(sals.sals[i]));
fe3f5fa8 14074
0d381245
VP
14075 /* Reparse conditions, they might contain references to the
14076 old symtab. */
14077 if (b->cond_string != NULL)
14078 {
bbc13ae3 14079 const char *s;
fe3f5fa8 14080
0d381245 14081 s = b->cond_string;
492d29ea 14082 TRY
0d381245 14083 {
1bb9788d
TT
14084 new_loc->cond = parse_exp_1 (&s, sals.sals[i].pc,
14085 block_for_pc (sals.sals[i].pc),
0d381245
VP
14086 0);
14087 }
492d29ea 14088 CATCH (e, RETURN_MASK_ERROR)
0d381245 14089 {
3e43a32a
MS
14090 warning (_("failed to reevaluate condition "
14091 "for breakpoint %d: %s"),
0d381245
VP
14092 b->number, e.message);
14093 new_loc->enabled = 0;
14094 }
492d29ea 14095 END_CATCH
0d381245 14096 }
fe3f5fa8 14097
f1310107
TJB
14098 if (sals_end.nelts)
14099 {
14100 CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
14101
14102 new_loc->length = end - sals.sals[0].pc + 1;
14103 }
0d381245 14104 }
fe3f5fa8 14105
4a64f543
MS
14106 /* If possible, carry over 'disable' status from existing
14107 breakpoints. */
0d381245
VP
14108 {
14109 struct bp_location *e = existing_locations;
776592bf
DE
14110 /* If there are multiple breakpoints with the same function name,
14111 e.g. for inline functions, comparing function names won't work.
14112 Instead compare pc addresses; this is just a heuristic as things
14113 may have moved, but in practice it gives the correct answer
14114 often enough until a better solution is found. */
14115 int have_ambiguous_names = ambiguous_names_p (b->loc);
14116
0d381245
VP
14117 for (; e; e = e->next)
14118 {
14119 if (!e->enabled && e->function_name)
14120 {
14121 struct bp_location *l = b->loc;
776592bf
DE
14122 if (have_ambiguous_names)
14123 {
14124 for (; l; l = l->next)
f1310107 14125 if (breakpoint_locations_match (e, l))
776592bf
DE
14126 {
14127 l->enabled = 0;
14128 break;
14129 }
14130 }
14131 else
14132 {
14133 for (; l; l = l->next)
14134 if (l->function_name
14135 && strcmp (e->function_name, l->function_name) == 0)
14136 {
14137 l->enabled = 0;
14138 break;
14139 }
14140 }
0d381245
VP
14141 }
14142 }
14143 }
fe3f5fa8 14144
8d3788bd
VP
14145 if (!locations_are_equal (existing_locations, b->loc))
14146 observer_notify_breakpoint_modified (b);
14147
44702360 14148 update_global_location_list (UGLL_MAY_INSERT);
fe3f5fa8
VP
14149}
14150
f00aae0f 14151/* Find the SaL locations corresponding to the given LOCATION.
ef23e705
TJB
14152 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
14153
14154static struct symtabs_and_lines
f00aae0f
KS
14155location_to_sals (struct breakpoint *b, struct event_location *location,
14156 int *found)
ef23e705 14157{
02d20e4a 14158 struct symtabs_and_lines sals = {0};
492d29ea 14159 struct gdb_exception exception = exception_none;
ef23e705 14160
983af33b 14161 gdb_assert (b->ops != NULL);
ef23e705 14162
492d29ea 14163 TRY
ef23e705 14164 {
f00aae0f 14165 b->ops->decode_location (b, location, &sals);
ef23e705 14166 }
492d29ea 14167 CATCH (e, RETURN_MASK_ERROR)
ef23e705
TJB
14168 {
14169 int not_found_and_ok = 0;
492d29ea
PA
14170
14171 exception = e;
14172
ef23e705
TJB
14173 /* For pending breakpoints, it's expected that parsing will
14174 fail until the right shared library is loaded. User has
14175 already told to create pending breakpoints and don't need
14176 extra messages. If breakpoint is in bp_shlib_disabled
14177 state, then user already saw the message about that
14178 breakpoint being disabled, and don't want to see more
14179 errors. */
58438ac1 14180 if (e.error == NOT_FOUND_ERROR
ef23e705
TJB
14181 && (b->condition_not_parsed
14182 || (b->loc && b->loc->shlib_disabled)
f8eba3c6 14183 || (b->loc && b->loc->pspace->executing_startup)
ef23e705
TJB
14184 || b->enable_state == bp_disabled))
14185 not_found_and_ok = 1;
14186
14187 if (!not_found_and_ok)
14188 {
14189 /* We surely don't want to warn about the same breakpoint
14190 10 times. One solution, implemented here, is disable
14191 the breakpoint on error. Another solution would be to
14192 have separate 'warning emitted' flag. Since this
14193 happens only when a binary has changed, I don't know
14194 which approach is better. */
14195 b->enable_state = bp_disabled;
14196 throw_exception (e);
14197 }
14198 }
492d29ea 14199 END_CATCH
ef23e705 14200
492d29ea 14201 if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
ef23e705 14202 {
f8eba3c6 14203 int i;
ef23e705 14204
f8eba3c6
TT
14205 for (i = 0; i < sals.nelts; ++i)
14206 resolve_sal_pc (&sals.sals[i]);
f00aae0f 14207 if (b->condition_not_parsed && b->extra_string != NULL)
ef23e705 14208 {
ed1d1739
KS
14209 char *cond_string, *extra_string;
14210 int thread, task;
ef23e705 14211
f00aae0f 14212 find_condition_and_thread (b->extra_string, sals.sals[0].pc,
e7e0cddf
SS
14213 &cond_string, &thread, &task,
14214 &extra_string);
f00aae0f 14215 gdb_assert (b->cond_string == NULL);
ef23e705
TJB
14216 if (cond_string)
14217 b->cond_string = cond_string;
14218 b->thread = thread;
14219 b->task = task;
e7e0cddf 14220 if (extra_string)
f00aae0f
KS
14221 {
14222 xfree (b->extra_string);
14223 b->extra_string = extra_string;
14224 }
ef23e705
TJB
14225 b->condition_not_parsed = 0;
14226 }
14227
983af33b 14228 if (b->type == bp_static_tracepoint && !strace_marker_p (b))
ef23e705 14229 sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
ef23e705 14230
58438ac1
TT
14231 *found = 1;
14232 }
14233 else
14234 *found = 0;
ef23e705
TJB
14235
14236 return sals;
14237}
14238
348d480f
PA
14239/* The default re_set method, for typical hardware or software
14240 breakpoints. Reevaluate the breakpoint and recreate its
14241 locations. */
14242
14243static void
28010a5d 14244breakpoint_re_set_default (struct breakpoint *b)
ef23e705
TJB
14245{
14246 int found;
f1310107 14247 struct symtabs_and_lines sals, sals_end;
ef23e705 14248 struct symtabs_and_lines expanded = {0};
f1310107 14249 struct symtabs_and_lines expanded_end = {0};
ef23e705 14250
f00aae0f 14251 sals = location_to_sals (b, b->location, &found);
ef23e705
TJB
14252 if (found)
14253 {
14254 make_cleanup (xfree, sals.sals);
f8eba3c6 14255 expanded = sals;
ef23e705
TJB
14256 }
14257
f00aae0f 14258 if (b->location_range_end != NULL)
f1310107 14259 {
f00aae0f 14260 sals_end = location_to_sals (b, b->location_range_end, &found);
f1310107
TJB
14261 if (found)
14262 {
14263 make_cleanup (xfree, sals_end.sals);
f8eba3c6 14264 expanded_end = sals_end;
f1310107
TJB
14265 }
14266 }
14267
14268 update_breakpoint_locations (b, expanded, expanded_end);
28010a5d
PA
14269}
14270
983af33b
SDJ
14271/* Default method for creating SALs from an address string. It basically
14272 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
14273
14274static void
f00aae0f
KS
14275create_sals_from_location_default (const struct event_location *location,
14276 struct linespec_result *canonical,
14277 enum bptype type_wanted)
983af33b 14278{
f00aae0f 14279 parse_breakpoint_sals (location, canonical);
983af33b
SDJ
14280}
14281
14282/* Call create_breakpoints_sal for the given arguments. This is the default
14283 function for the `create_breakpoints_sal' method of
14284 breakpoint_ops. */
14285
14286static void
14287create_breakpoints_sal_default (struct gdbarch *gdbarch,
14288 struct linespec_result *canonical,
983af33b 14289 char *cond_string,
e7e0cddf 14290 char *extra_string,
983af33b
SDJ
14291 enum bptype type_wanted,
14292 enum bpdisp disposition,
14293 int thread,
14294 int task, int ignore_count,
14295 const struct breakpoint_ops *ops,
14296 int from_tty, int enabled,
44f238bb 14297 int internal, unsigned flags)
983af33b
SDJ
14298{
14299 create_breakpoints_sal (gdbarch, canonical, cond_string,
e7e0cddf 14300 extra_string,
983af33b
SDJ
14301 type_wanted, disposition,
14302 thread, task, ignore_count, ops, from_tty,
44f238bb 14303 enabled, internal, flags);
983af33b
SDJ
14304}
14305
14306/* Decode the line represented by S by calling decode_line_full. This is the
5f700d83 14307 default function for the `decode_location' method of breakpoint_ops. */
983af33b
SDJ
14308
14309static void
f00aae0f
KS
14310decode_location_default (struct breakpoint *b,
14311 const struct event_location *location,
983af33b
SDJ
14312 struct symtabs_and_lines *sals)
14313{
14314 struct linespec_result canonical;
14315
14316 init_linespec_result (&canonical);
f00aae0f 14317 decode_line_full (location, DECODE_LINE_FUNFIRSTLINE,
983af33b
SDJ
14318 (struct symtab *) NULL, 0,
14319 &canonical, multiple_symbols_all,
14320 b->filter);
14321
14322 /* We should get 0 or 1 resulting SALs. */
14323 gdb_assert (VEC_length (linespec_sals, canonical.sals) < 2);
14324
14325 if (VEC_length (linespec_sals, canonical.sals) > 0)
14326 {
14327 struct linespec_sals *lsal;
14328
14329 lsal = VEC_index (linespec_sals, canonical.sals, 0);
14330 *sals = lsal->sals;
14331 /* Arrange it so the destructor does not free the
14332 contents. */
14333 lsal->sals.sals = NULL;
14334 }
14335
14336 destroy_linespec_result (&canonical);
14337}
14338
28010a5d
PA
14339/* Prepare the global context for a re-set of breakpoint B. */
14340
14341static struct cleanup *
14342prepare_re_set_context (struct breakpoint *b)
14343{
14344 struct cleanup *cleanups;
14345
14346 input_radix = b->input_radix;
14347 cleanups = save_current_space_and_thread ();
f8eba3c6
TT
14348 if (b->pspace != NULL)
14349 switch_to_program_space_and_thread (b->pspace);
28010a5d
PA
14350 set_language (b->language);
14351
14352 return cleanups;
ef23e705
TJB
14353}
14354
c906108c
SS
14355/* Reset a breakpoint given it's struct breakpoint * BINT.
14356 The value we return ends up being the return value from catch_errors.
14357 Unused in this case. */
14358
14359static int
4efb68b1 14360breakpoint_re_set_one (void *bint)
c906108c 14361{
4a64f543 14362 /* Get past catch_errs. */
53a5351d 14363 struct breakpoint *b = (struct breakpoint *) bint;
348d480f 14364 struct cleanup *cleanups;
c906108c 14365
348d480f
PA
14366 cleanups = prepare_re_set_context (b);
14367 b->ops->re_set (b);
14368 do_cleanups (cleanups);
c906108c
SS
14369 return 0;
14370}
14371
69de3c6a 14372/* Re-set all breakpoints after symbols have been re-loaded. */
c906108c 14373void
69de3c6a 14374breakpoint_re_set (void)
c906108c 14375{
35df4500 14376 struct breakpoint *b, *b_tmp;
c906108c
SS
14377 enum language save_language;
14378 int save_input_radix;
6c95b8df 14379 struct cleanup *old_chain;
c5aa993b 14380
c906108c
SS
14381 save_language = current_language->la_language;
14382 save_input_radix = input_radix;
6c95b8df
PA
14383 old_chain = save_current_program_space ();
14384
35df4500 14385 ALL_BREAKPOINTS_SAFE (b, b_tmp)
c5aa993b 14386 {
4a64f543 14387 /* Format possible error msg. */
fe3f5fa8 14388 char *message = xstrprintf ("Error in re-setting breakpoint %d: ",
9ebf4acf
AC
14389 b->number);
14390 struct cleanup *cleanups = make_cleanup (xfree, message);
c5aa993b 14391 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
9ebf4acf 14392 do_cleanups (cleanups);
c5aa993b 14393 }
c906108c
SS
14394 set_language (save_language);
14395 input_radix = save_input_radix;
e62c965a 14396
0756c555 14397 jit_breakpoint_re_set ();
4efc6507 14398
6c95b8df
PA
14399 do_cleanups (old_chain);
14400
af02033e
PP
14401 create_overlay_event_breakpoint ();
14402 create_longjmp_master_breakpoint ();
14403 create_std_terminate_master_breakpoint ();
186c406b 14404 create_exception_master_breakpoint ();
c906108c
SS
14405}
14406\f
c906108c
SS
14407/* Reset the thread number of this breakpoint:
14408
14409 - If the breakpoint is for all threads, leave it as-is.
4a64f543 14410 - Else, reset it to the current thread for inferior_ptid. */
c906108c 14411void
fba45db2 14412breakpoint_re_set_thread (struct breakpoint *b)
c906108c
SS
14413{
14414 if (b->thread != -1)
14415 {
39f77062
KB
14416 if (in_thread_list (inferior_ptid))
14417 b->thread = pid_to_thread_id (inferior_ptid);
6c95b8df
PA
14418
14419 /* We're being called after following a fork. The new fork is
14420 selected as current, and unless this was a vfork will have a
14421 different program space from the original thread. Reset that
14422 as well. */
14423 b->loc->pspace = current_program_space;
c906108c
SS
14424 }
14425}
14426
03ac34d5
MS
14427/* Set ignore-count of breakpoint number BPTNUM to COUNT.
14428 If from_tty is nonzero, it prints a message to that effect,
14429 which ends with a period (no newline). */
14430
c906108c 14431void
fba45db2 14432set_ignore_count (int bptnum, int count, int from_tty)
c906108c 14433{
52f0bd74 14434 struct breakpoint *b;
c906108c
SS
14435
14436 if (count < 0)
14437 count = 0;
14438
14439 ALL_BREAKPOINTS (b)
14440 if (b->number == bptnum)
c5aa993b 14441 {
d77f58be
SS
14442 if (is_tracepoint (b))
14443 {
14444 if (from_tty && count != 0)
14445 printf_filtered (_("Ignore count ignored for tracepoint %d."),
14446 bptnum);
14447 return;
14448 }
14449
c5aa993b 14450 b->ignore_count = count;
221ea385
KS
14451 if (from_tty)
14452 {
14453 if (count == 0)
3e43a32a
MS
14454 printf_filtered (_("Will stop next time "
14455 "breakpoint %d is reached."),
221ea385
KS
14456 bptnum);
14457 else if (count == 1)
a3f17187 14458 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
221ea385
KS
14459 bptnum);
14460 else
3e43a32a
MS
14461 printf_filtered (_("Will ignore next %d "
14462 "crossings of breakpoint %d."),
221ea385
KS
14463 count, bptnum);
14464 }
8d3788bd 14465 observer_notify_breakpoint_modified (b);
c5aa993b
JM
14466 return;
14467 }
c906108c 14468
8a3fe4f8 14469 error (_("No breakpoint number %d."), bptnum);
c906108c
SS
14470}
14471
c906108c
SS
14472/* Command to set ignore-count of breakpoint N to COUNT. */
14473
14474static void
fba45db2 14475ignore_command (char *args, int from_tty)
c906108c
SS
14476{
14477 char *p = args;
52f0bd74 14478 int num;
c906108c
SS
14479
14480 if (p == 0)
e2e0b3e5 14481 error_no_arg (_("a breakpoint number"));
c5aa993b 14482
c906108c 14483 num = get_number (&p);
5c44784c 14484 if (num == 0)
8a3fe4f8 14485 error (_("bad breakpoint number: '%s'"), args);
c906108c 14486 if (*p == 0)
8a3fe4f8 14487 error (_("Second argument (specified ignore-count) is missing."));
c906108c
SS
14488
14489 set_ignore_count (num,
14490 longest_to_int (value_as_long (parse_and_eval (p))),
14491 from_tty);
221ea385
KS
14492 if (from_tty)
14493 printf_filtered ("\n");
c906108c
SS
14494}
14495\f
14496/* Call FUNCTION on each of the breakpoints
14497 whose numbers are given in ARGS. */
14498
14499static void
95a42b64
TT
14500map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
14501 void *),
14502 void *data)
c906108c 14503{
52f0bd74
AC
14504 int num;
14505 struct breakpoint *b, *tmp;
11cf8741 14506 int match;
197f0a60 14507 struct get_number_or_range_state state;
c906108c 14508
b9d61307 14509 if (args == 0 || *args == '\0')
e2e0b3e5 14510 error_no_arg (_("one or more breakpoint numbers"));
c906108c 14511
197f0a60
TT
14512 init_number_or_range (&state, args);
14513
14514 while (!state.finished)
c906108c 14515 {
e799154c 14516 const char *p = state.string;
197f0a60 14517
11cf8741 14518 match = 0;
c5aa993b 14519
197f0a60 14520 num = get_number_or_range (&state);
5c44784c 14521 if (num == 0)
c5aa993b 14522 {
8a3fe4f8 14523 warning (_("bad breakpoint number at or near '%s'"), p);
5c44784c
JM
14524 }
14525 else
14526 {
14527 ALL_BREAKPOINTS_SAFE (b, tmp)
14528 if (b->number == num)
14529 {
11cf8741 14530 match = 1;
cdac0397 14531 function (b, data);
11cf8741 14532 break;
5c44784c 14533 }
11cf8741 14534 if (match == 0)
a3f17187 14535 printf_unfiltered (_("No breakpoint number %d.\n"), num);
c5aa993b 14536 }
c906108c
SS
14537 }
14538}
14539
0d381245
VP
14540static struct bp_location *
14541find_location_by_number (char *number)
14542{
14543 char *dot = strchr (number, '.');
14544 char *p1;
14545 int bp_num;
14546 int loc_num;
14547 struct breakpoint *b;
14548 struct bp_location *loc;
14549
14550 *dot = '\0';
14551
14552 p1 = number;
197f0a60 14553 bp_num = get_number (&p1);
0d381245
VP
14554 if (bp_num == 0)
14555 error (_("Bad breakpoint number '%s'"), number);
14556
14557 ALL_BREAKPOINTS (b)
14558 if (b->number == bp_num)
14559 {
14560 break;
14561 }
14562
14563 if (!b || b->number != bp_num)
14564 error (_("Bad breakpoint number '%s'"), number);
14565
14566 p1 = dot+1;
197f0a60 14567 loc_num = get_number (&p1);
0d381245
VP
14568 if (loc_num == 0)
14569 error (_("Bad breakpoint location number '%s'"), number);
14570
14571 --loc_num;
14572 loc = b->loc;
14573 for (;loc_num && loc; --loc_num, loc = loc->next)
14574 ;
14575 if (!loc)
14576 error (_("Bad breakpoint location number '%s'"), dot+1);
14577
14578 return loc;
14579}
14580
14581
1900040c
MS
14582/* Set ignore-count of breakpoint number BPTNUM to COUNT.
14583 If from_tty is nonzero, it prints a message to that effect,
14584 which ends with a period (no newline). */
14585
c906108c 14586void
fba45db2 14587disable_breakpoint (struct breakpoint *bpt)
c906108c
SS
14588{
14589 /* Never disable a watchpoint scope breakpoint; we want to
14590 hit them when we leave scope so we can delete both the
14591 watchpoint and its scope breakpoint at that time. */
14592 if (bpt->type == bp_watchpoint_scope)
14593 return;
14594
b5de0fa7 14595 bpt->enable_state = bp_disabled;
c906108c 14596
b775012e
LM
14597 /* Mark breakpoint locations modified. */
14598 mark_breakpoint_modified (bpt);
14599
d248b706
KY
14600 if (target_supports_enable_disable_tracepoint ()
14601 && current_trace_status ()->running && is_tracepoint (bpt))
14602 {
14603 struct bp_location *location;
14604
14605 for (location = bpt->loc; location; location = location->next)
14606 target_disable_tracepoint (location);
14607 }
14608
44702360 14609 update_global_location_list (UGLL_DONT_INSERT);
c906108c 14610
8d3788bd 14611 observer_notify_breakpoint_modified (bpt);
c906108c
SS
14612}
14613
51be5b68
PA
14614/* A callback for iterate_over_related_breakpoints. */
14615
14616static void
14617do_disable_breakpoint (struct breakpoint *b, void *ignore)
14618{
14619 disable_breakpoint (b);
14620}
14621
95a42b64
TT
14622/* A callback for map_breakpoint_numbers that calls
14623 disable_breakpoint. */
14624
14625static void
14626do_map_disable_breakpoint (struct breakpoint *b, void *ignore)
14627{
51be5b68 14628 iterate_over_related_breakpoints (b, do_disable_breakpoint, NULL);
95a42b64
TT
14629}
14630
c906108c 14631static void
fba45db2 14632disable_command (char *args, int from_tty)
c906108c 14633{
c906108c 14634 if (args == 0)
46c6471b
PA
14635 {
14636 struct breakpoint *bpt;
14637
14638 ALL_BREAKPOINTS (bpt)
14639 if (user_breakpoint_p (bpt))
14640 disable_breakpoint (bpt);
14641 }
9eaabc75 14642 else
0d381245 14643 {
9eaabc75
MW
14644 char *num = extract_arg (&args);
14645
14646 while (num)
d248b706 14647 {
9eaabc75 14648 if (strchr (num, '.'))
b775012e 14649 {
9eaabc75
MW
14650 struct bp_location *loc = find_location_by_number (num);
14651
14652 if (loc)
14653 {
14654 if (loc->enabled)
14655 {
14656 loc->enabled = 0;
14657 mark_breakpoint_location_modified (loc);
14658 }
14659 if (target_supports_enable_disable_tracepoint ()
14660 && current_trace_status ()->running && loc->owner
14661 && is_tracepoint (loc->owner))
14662 target_disable_tracepoint (loc);
14663 }
44702360 14664 update_global_location_list (UGLL_DONT_INSERT);
b775012e 14665 }
9eaabc75
MW
14666 else
14667 map_breakpoint_numbers (num, do_map_disable_breakpoint, NULL);
14668 num = extract_arg (&args);
d248b706 14669 }
0d381245 14670 }
c906108c
SS
14671}
14672
14673static void
816338b5
SS
14674enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
14675 int count)
c906108c 14676{
afe38095 14677 int target_resources_ok;
c906108c
SS
14678
14679 if (bpt->type == bp_hardware_breakpoint)
14680 {
14681 int i;
c5aa993b 14682 i = hw_breakpoint_used_count ();
53a5351d 14683 target_resources_ok =
d92524f1 14684 target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
53a5351d 14685 i + 1, 0);
c906108c 14686 if (target_resources_ok == 0)
8a3fe4f8 14687 error (_("No hardware breakpoint support in the target."));
c906108c 14688 else if (target_resources_ok < 0)
8a3fe4f8 14689 error (_("Hardware breakpoints used exceeds limit."));
c906108c
SS
14690 }
14691
cc60f2e3 14692 if (is_watchpoint (bpt))
c906108c 14693 {
d07205c2 14694 /* Initialize it just to avoid a GCC false warning. */
f486487f 14695 enum enable_state orig_enable_state = bp_disabled;
dde02812 14696
492d29ea 14697 TRY
c906108c 14698 {
3a5c3e22
PA
14699 struct watchpoint *w = (struct watchpoint *) bpt;
14700
1e718ff1
TJB
14701 orig_enable_state = bpt->enable_state;
14702 bpt->enable_state = bp_enabled;
3a5c3e22 14703 update_watchpoint (w, 1 /* reparse */);
c906108c 14704 }
492d29ea 14705 CATCH (e, RETURN_MASK_ALL)
c5aa993b 14706 {
1e718ff1 14707 bpt->enable_state = orig_enable_state;
dde02812
ES
14708 exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
14709 bpt->number);
14710 return;
c5aa993b 14711 }
492d29ea 14712 END_CATCH
c906108c 14713 }
0101ce28 14714
b775012e
LM
14715 bpt->enable_state = bp_enabled;
14716
14717 /* Mark breakpoint locations modified. */
14718 mark_breakpoint_modified (bpt);
14719
d248b706
KY
14720 if (target_supports_enable_disable_tracepoint ()
14721 && current_trace_status ()->running && is_tracepoint (bpt))
14722 {
14723 struct bp_location *location;
14724
14725 for (location = bpt->loc; location; location = location->next)
14726 target_enable_tracepoint (location);
14727 }
14728
b4c291bb 14729 bpt->disposition = disposition;
816338b5 14730 bpt->enable_count = count;
44702360 14731 update_global_location_list (UGLL_MAY_INSERT);
9c97429f 14732
8d3788bd 14733 observer_notify_breakpoint_modified (bpt);
c906108c
SS
14734}
14735
fe3f5fa8 14736
c906108c 14737void
fba45db2 14738enable_breakpoint (struct breakpoint *bpt)
c906108c 14739{
816338b5 14740 enable_breakpoint_disp (bpt, bpt->disposition, 0);
51be5b68
PA
14741}
14742
14743static void
14744do_enable_breakpoint (struct breakpoint *bpt, void *arg)
14745{
14746 enable_breakpoint (bpt);
c906108c
SS
14747}
14748
95a42b64
TT
14749/* A callback for map_breakpoint_numbers that calls
14750 enable_breakpoint. */
14751
14752static void
14753do_map_enable_breakpoint (struct breakpoint *b, void *ignore)
14754{
51be5b68 14755 iterate_over_related_breakpoints (b, do_enable_breakpoint, NULL);
95a42b64
TT
14756}
14757
c906108c
SS
14758/* The enable command enables the specified breakpoints (or all defined
14759 breakpoints) so they once again become (or continue to be) effective
1272ad14 14760 in stopping the inferior. */
c906108c 14761
c906108c 14762static void
fba45db2 14763enable_command (char *args, int from_tty)
c906108c 14764{
c906108c 14765 if (args == 0)
46c6471b
PA
14766 {
14767 struct breakpoint *bpt;
14768
14769 ALL_BREAKPOINTS (bpt)
14770 if (user_breakpoint_p (bpt))
14771 enable_breakpoint (bpt);
14772 }
9eaabc75 14773 else
0d381245 14774 {
9eaabc75
MW
14775 char *num = extract_arg (&args);
14776
14777 while (num)
d248b706 14778 {
9eaabc75 14779 if (strchr (num, '.'))
b775012e 14780 {
9eaabc75
MW
14781 struct bp_location *loc = find_location_by_number (num);
14782
14783 if (loc)
14784 {
14785 if (!loc->enabled)
14786 {
14787 loc->enabled = 1;
14788 mark_breakpoint_location_modified (loc);
14789 }
14790 if (target_supports_enable_disable_tracepoint ()
14791 && current_trace_status ()->running && loc->owner
14792 && is_tracepoint (loc->owner))
14793 target_enable_tracepoint (loc);
14794 }
44702360 14795 update_global_location_list (UGLL_MAY_INSERT);
b775012e 14796 }
9eaabc75
MW
14797 else
14798 map_breakpoint_numbers (num, do_map_enable_breakpoint, NULL);
14799 num = extract_arg (&args);
d248b706 14800 }
0d381245 14801 }
c906108c
SS
14802}
14803
816338b5
SS
14804/* This struct packages up disposition data for application to multiple
14805 breakpoints. */
14806
14807struct disp_data
14808{
14809 enum bpdisp disp;
14810 int count;
14811};
14812
c906108c 14813static void
51be5b68
PA
14814do_enable_breakpoint_disp (struct breakpoint *bpt, void *arg)
14815{
816338b5 14816 struct disp_data disp_data = *(struct disp_data *) arg;
51be5b68 14817
816338b5 14818 enable_breakpoint_disp (bpt, disp_data.disp, disp_data.count);
51be5b68
PA
14819}
14820
14821static void
14822do_map_enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
c906108c 14823{
816338b5 14824 struct disp_data disp = { disp_disable, 1 };
51be5b68
PA
14825
14826 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
c906108c
SS
14827}
14828
c906108c 14829static void
fba45db2 14830enable_once_command (char *args, int from_tty)
c906108c 14831{
51be5b68 14832 map_breakpoint_numbers (args, do_map_enable_once_breakpoint, NULL);
c906108c
SS
14833}
14834
816338b5
SS
14835static void
14836do_map_enable_count_breakpoint (struct breakpoint *bpt, void *countptr)
14837{
14838 struct disp_data disp = { disp_disable, *(int *) countptr };
14839
14840 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
14841}
14842
14843static void
14844enable_count_command (char *args, int from_tty)
14845{
b9d61307
SM
14846 int count;
14847
14848 if (args == NULL)
14849 error_no_arg (_("hit count"));
14850
14851 count = get_number (&args);
816338b5
SS
14852
14853 map_breakpoint_numbers (args, do_map_enable_count_breakpoint, &count);
14854}
14855
c906108c 14856static void
51be5b68 14857do_map_enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
c906108c 14858{
816338b5 14859 struct disp_data disp = { disp_del, 1 };
51be5b68
PA
14860
14861 iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
c906108c
SS
14862}
14863
c906108c 14864static void
fba45db2 14865enable_delete_command (char *args, int from_tty)
c906108c 14866{
51be5b68 14867 map_breakpoint_numbers (args, do_map_enable_delete_breakpoint, NULL);
c906108c
SS
14868}
14869\f
fa8d40ab
JJ
14870static void
14871set_breakpoint_cmd (char *args, int from_tty)
14872{
14873}
14874
14875static void
14876show_breakpoint_cmd (char *args, int from_tty)
14877{
14878}
14879
1f3b5d1b
PP
14880/* Invalidate last known value of any hardware watchpoint if
14881 the memory which that value represents has been written to by
14882 GDB itself. */
14883
14884static void
8de0566d
YQ
14885invalidate_bp_value_on_memory_change (struct inferior *inferior,
14886 CORE_ADDR addr, ssize_t len,
1f3b5d1b
PP
14887 const bfd_byte *data)
14888{
14889 struct breakpoint *bp;
14890
14891 ALL_BREAKPOINTS (bp)
14892 if (bp->enable_state == bp_enabled
3a5c3e22 14893 && bp->type == bp_hardware_watchpoint)
1f3b5d1b 14894 {
3a5c3e22 14895 struct watchpoint *wp = (struct watchpoint *) bp;
1f3b5d1b 14896
3a5c3e22
PA
14897 if (wp->val_valid && wp->val)
14898 {
14899 struct bp_location *loc;
14900
14901 for (loc = bp->loc; loc != NULL; loc = loc->next)
14902 if (loc->loc_type == bp_loc_hardware_watchpoint
14903 && loc->address + loc->length > addr
14904 && addr + len > loc->address)
14905 {
14906 value_free (wp->val);
14907 wp->val = NULL;
14908 wp->val_valid = 0;
14909 }
14910 }
1f3b5d1b
PP
14911 }
14912}
14913
8181d85f
DJ
14914/* Create and insert a breakpoint for software single step. */
14915
14916void
6c95b8df 14917insert_single_step_breakpoint (struct gdbarch *gdbarch,
4a64f543
MS
14918 struct address_space *aspace,
14919 CORE_ADDR next_pc)
8181d85f 14920{
7c16b83e
PA
14921 struct thread_info *tp = inferior_thread ();
14922 struct symtab_and_line sal;
14923 CORE_ADDR pc = next_pc;
8181d85f 14924
34b7e8a6
PA
14925 if (tp->control.single_step_breakpoints == NULL)
14926 {
14927 tp->control.single_step_breakpoints
14928 = new_single_step_breakpoint (tp->num, gdbarch);
14929 }
8181d85f 14930
7c16b83e
PA
14931 sal = find_pc_line (pc, 0);
14932 sal.pc = pc;
14933 sal.section = find_pc_overlay (pc);
14934 sal.explicit_pc = 1;
34b7e8a6 14935 add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
8181d85f 14936
7c16b83e 14937 update_global_location_list (UGLL_INSERT);
8181d85f
DJ
14938}
14939
34b7e8a6 14940/* See breakpoint.h. */
f02253f1
HZ
14941
14942int
7c16b83e
PA
14943breakpoint_has_location_inserted_here (struct breakpoint *bp,
14944 struct address_space *aspace,
14945 CORE_ADDR pc)
1aafd4da 14946{
7c16b83e 14947 struct bp_location *loc;
1aafd4da 14948
7c16b83e
PA
14949 for (loc = bp->loc; loc != NULL; loc = loc->next)
14950 if (loc->inserted
14951 && breakpoint_location_address_match (loc, aspace, pc))
14952 return 1;
1aafd4da 14953
7c16b83e 14954 return 0;
ef370185
JB
14955}
14956
14957/* Check whether a software single-step breakpoint is inserted at
14958 PC. */
14959
14960int
14961single_step_breakpoint_inserted_here_p (struct address_space *aspace,
14962 CORE_ADDR pc)
14963{
34b7e8a6
PA
14964 struct breakpoint *bpt;
14965
14966 ALL_BREAKPOINTS (bpt)
14967 {
14968 if (bpt->type == bp_single_step
14969 && breakpoint_has_location_inserted_here (bpt, aspace, pc))
14970 return 1;
14971 }
14972 return 0;
1aafd4da
UW
14973}
14974
1042e4c0
SS
14975/* Tracepoint-specific operations. */
14976
14977/* Set tracepoint count to NUM. */
14978static void
14979set_tracepoint_count (int num)
14980{
14981 tracepoint_count = num;
4fa62494 14982 set_internalvar_integer (lookup_internalvar ("tpnum"), num);
1042e4c0
SS
14983}
14984
70221824 14985static void
1042e4c0
SS
14986trace_command (char *arg, int from_tty)
14987{
55aa24fb 14988 struct breakpoint_ops *ops;
f00aae0f
KS
14989 struct event_location *location;
14990 struct cleanup *back_to;
55aa24fb 14991
f00aae0f
KS
14992 location = string_to_event_location (&arg, current_language);
14993 back_to = make_cleanup_delete_event_location (location);
5b56227b
KS
14994 if (location != NULL
14995 && event_location_type (location) == PROBE_LOCATION)
55aa24fb
SDJ
14996 ops = &tracepoint_probe_breakpoint_ops;
14997 else
14998 ops = &tracepoint_breakpoint_ops;
14999
558a9d82 15000 create_breakpoint (get_current_arch (),
f00aae0f
KS
15001 location,
15002 NULL, 0, arg, 1 /* parse arg */,
558a9d82
YQ
15003 0 /* tempflag */,
15004 bp_tracepoint /* type_wanted */,
15005 0 /* Ignore count */,
15006 pending_break_support,
15007 ops,
15008 from_tty,
15009 1 /* enabled */,
15010 0 /* internal */, 0);
f00aae0f 15011 do_cleanups (back_to);
1042e4c0
SS
15012}
15013
70221824 15014static void
7a697b8d
SS
15015ftrace_command (char *arg, int from_tty)
15016{
f00aae0f
KS
15017 struct event_location *location;
15018 struct cleanup *back_to;
15019
15020 location = string_to_event_location (&arg, current_language);
15021 back_to = make_cleanup_delete_event_location (location);
558a9d82 15022 create_breakpoint (get_current_arch (),
f00aae0f
KS
15023 location,
15024 NULL, 0, arg, 1 /* parse arg */,
558a9d82
YQ
15025 0 /* tempflag */,
15026 bp_fast_tracepoint /* type_wanted */,
15027 0 /* Ignore count */,
15028 pending_break_support,
15029 &tracepoint_breakpoint_ops,
15030 from_tty,
15031 1 /* enabled */,
15032 0 /* internal */, 0);
f00aae0f 15033 do_cleanups (back_to);
0fb4aa4b
PA
15034}
15035
15036/* strace command implementation. Creates a static tracepoint. */
15037
70221824 15038static void
0fb4aa4b
PA
15039strace_command (char *arg, int from_tty)
15040{
983af33b 15041 struct breakpoint_ops *ops;
f00aae0f
KS
15042 struct event_location *location;
15043 struct cleanup *back_to;
983af33b
SDJ
15044
15045 /* Decide if we are dealing with a static tracepoint marker (`-m'),
15046 or with a normal static tracepoint. */
61012eef 15047 if (arg && startswith (arg, "-m") && isspace (arg[2]))
f00aae0f
KS
15048 {
15049 ops = &strace_marker_breakpoint_ops;
15050 location = new_linespec_location (&arg);
15051 }
983af33b 15052 else
f00aae0f
KS
15053 {
15054 ops = &tracepoint_breakpoint_ops;
15055 location = string_to_event_location (&arg, current_language);
15056 }
983af33b 15057
f00aae0f 15058 back_to = make_cleanup_delete_event_location (location);
558a9d82 15059 create_breakpoint (get_current_arch (),
f00aae0f
KS
15060 location,
15061 NULL, 0, arg, 1 /* parse arg */,
558a9d82
YQ
15062 0 /* tempflag */,
15063 bp_static_tracepoint /* type_wanted */,
15064 0 /* Ignore count */,
15065 pending_break_support,
15066 ops,
15067 from_tty,
15068 1 /* enabled */,
15069 0 /* internal */, 0);
f00aae0f 15070 do_cleanups (back_to);
7a697b8d
SS
15071}
15072
409873ef
SS
15073/* Set up a fake reader function that gets command lines from a linked
15074 list that was acquired during tracepoint uploading. */
15075
15076static struct uploaded_tp *this_utp;
3149d8c1 15077static int next_cmd;
409873ef
SS
15078
15079static char *
15080read_uploaded_action (void)
15081{
15082 char *rslt;
15083
3149d8c1 15084 VEC_iterate (char_ptr, this_utp->cmd_strings, next_cmd, rslt);
409873ef 15085
3149d8c1 15086 next_cmd++;
409873ef
SS
15087
15088 return rslt;
15089}
15090
00bf0b85
SS
15091/* Given information about a tracepoint as recorded on a target (which
15092 can be either a live system or a trace file), attempt to create an
15093 equivalent GDB tracepoint. This is not a reliable process, since
15094 the target does not necessarily have all the information used when
15095 the tracepoint was originally defined. */
15096
d9b3f62e 15097struct tracepoint *
00bf0b85 15098create_tracepoint_from_upload (struct uploaded_tp *utp)
d5551862 15099{
409873ef 15100 char *addr_str, small_buf[100];
d9b3f62e 15101 struct tracepoint *tp;
f00aae0f
KS
15102 struct event_location *location;
15103 struct cleanup *cleanup;
fd9b8c24 15104
409873ef
SS
15105 if (utp->at_string)
15106 addr_str = utp->at_string;
15107 else
15108 {
15109 /* In the absence of a source location, fall back to raw
15110 address. Since there is no way to confirm that the address
15111 means the same thing as when the trace was started, warn the
15112 user. */
3e43a32a
MS
15113 warning (_("Uploaded tracepoint %d has no "
15114 "source location, using raw address"),
409873ef 15115 utp->number);
8c042590 15116 xsnprintf (small_buf, sizeof (small_buf), "*%s", hex_string (utp->addr));
409873ef
SS
15117 addr_str = small_buf;
15118 }
15119
15120 /* There's not much we can do with a sequence of bytecodes. */
15121 if (utp->cond && !utp->cond_string)
3e43a32a
MS
15122 warning (_("Uploaded tracepoint %d condition "
15123 "has no source form, ignoring it"),
409873ef 15124 utp->number);
d5551862 15125
f00aae0f
KS
15126 location = string_to_event_location (&addr_str, current_language);
15127 cleanup = make_cleanup_delete_event_location (location);
8cdf0e15 15128 if (!create_breakpoint (get_current_arch (),
f00aae0f
KS
15129 location,
15130 utp->cond_string, -1, addr_str,
e7e0cddf 15131 0 /* parse cond/thread */,
8cdf0e15 15132 0 /* tempflag */,
0fb4aa4b 15133 utp->type /* type_wanted */,
8cdf0e15
VP
15134 0 /* Ignore count */,
15135 pending_break_support,
348d480f 15136 &tracepoint_breakpoint_ops,
8cdf0e15 15137 0 /* from_tty */,
84f4c1fe 15138 utp->enabled /* enabled */,
44f238bb
PA
15139 0 /* internal */,
15140 CREATE_BREAKPOINT_FLAGS_INSERTED))
f00aae0f
KS
15141 {
15142 do_cleanups (cleanup);
15143 return NULL;
15144 }
15145
15146 do_cleanups (cleanup);
fd9b8c24 15147
409873ef 15148 /* Get the tracepoint we just created. */
fd9b8c24
PA
15149 tp = get_tracepoint (tracepoint_count);
15150 gdb_assert (tp != NULL);
d5551862 15151
00bf0b85
SS
15152 if (utp->pass > 0)
15153 {
8c042590
PM
15154 xsnprintf (small_buf, sizeof (small_buf), "%d %d", utp->pass,
15155 tp->base.number);
00bf0b85 15156
409873ef 15157 trace_pass_command (small_buf, 0);
00bf0b85
SS
15158 }
15159
409873ef
SS
15160 /* If we have uploaded versions of the original commands, set up a
15161 special-purpose "reader" function and call the usual command line
15162 reader, then pass the result to the breakpoint command-setting
15163 function. */
3149d8c1 15164 if (!VEC_empty (char_ptr, utp->cmd_strings))
00bf0b85 15165 {
409873ef 15166 struct command_line *cmd_list;
00bf0b85 15167
409873ef 15168 this_utp = utp;
3149d8c1 15169 next_cmd = 0;
d5551862 15170
409873ef
SS
15171 cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
15172
d9b3f62e 15173 breakpoint_set_commands (&tp->base, cmd_list);
00bf0b85 15174 }
3149d8c1
SS
15175 else if (!VEC_empty (char_ptr, utp->actions)
15176 || !VEC_empty (char_ptr, utp->step_actions))
3e43a32a
MS
15177 warning (_("Uploaded tracepoint %d actions "
15178 "have no source form, ignoring them"),
409873ef 15179 utp->number);
00bf0b85 15180
f196051f
SS
15181 /* Copy any status information that might be available. */
15182 tp->base.hit_count = utp->hit_count;
15183 tp->traceframe_usage = utp->traceframe_usage;
15184
00bf0b85 15185 return tp;
d9b3f62e 15186}
00bf0b85 15187
1042e4c0
SS
15188/* Print information on tracepoint number TPNUM_EXP, or all if
15189 omitted. */
15190
15191static void
e5a67952 15192tracepoints_info (char *args, int from_tty)
1042e4c0 15193{
79a45e25 15194 struct ui_out *uiout = current_uiout;
e5a67952 15195 int num_printed;
1042e4c0 15196
e5a67952 15197 num_printed = breakpoint_1 (args, 0, is_tracepoint);
d77f58be
SS
15198
15199 if (num_printed == 0)
1042e4c0 15200 {
e5a67952 15201 if (args == NULL || *args == '\0')
d77f58be
SS
15202 ui_out_message (uiout, 0, "No tracepoints.\n");
15203 else
e5a67952 15204 ui_out_message (uiout, 0, "No tracepoint matching '%s'.\n", args);
1042e4c0 15205 }
ad443146
SS
15206
15207 default_collect_info ();
1042e4c0
SS
15208}
15209
4a64f543 15210/* The 'enable trace' command enables tracepoints.
1042e4c0
SS
15211 Not supported by all targets. */
15212static void
15213enable_trace_command (char *args, int from_tty)
15214{
15215 enable_command (args, from_tty);
15216}
15217
4a64f543 15218/* The 'disable trace' command disables tracepoints.
1042e4c0
SS
15219 Not supported by all targets. */
15220static void
15221disable_trace_command (char *args, int from_tty)
15222{
15223 disable_command (args, from_tty);
15224}
15225
4a64f543 15226/* Remove a tracepoint (or all if no argument). */
1042e4c0
SS
15227static void
15228delete_trace_command (char *arg, int from_tty)
15229{
35df4500 15230 struct breakpoint *b, *b_tmp;
1042e4c0
SS
15231
15232 dont_repeat ();
15233
15234 if (arg == 0)
15235 {
15236 int breaks_to_delete = 0;
15237
15238 /* Delete all breakpoints if no argument.
15239 Do not delete internal or call-dummy breakpoints, these
4a64f543
MS
15240 have to be deleted with an explicit breakpoint number
15241 argument. */
1042e4c0 15242 ALL_TRACEPOINTS (b)
46c6471b 15243 if (is_tracepoint (b) && user_breakpoint_p (b))
1042e4c0
SS
15244 {
15245 breaks_to_delete = 1;
15246 break;
15247 }
1042e4c0
SS
15248
15249 /* Ask user only if there are some breakpoints to delete. */
15250 if (!from_tty
15251 || (breaks_to_delete && query (_("Delete all tracepoints? "))))
15252 {
35df4500 15253 ALL_BREAKPOINTS_SAFE (b, b_tmp)
46c6471b 15254 if (is_tracepoint (b) && user_breakpoint_p (b))
1042e4c0 15255 delete_breakpoint (b);
1042e4c0
SS
15256 }
15257 }
15258 else
51be5b68 15259 map_breakpoint_numbers (arg, do_map_delete_breakpoint, NULL);
1042e4c0
SS
15260}
15261
197f0a60
TT
15262/* Helper function for trace_pass_command. */
15263
15264static void
d9b3f62e 15265trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
197f0a60 15266{
d9b3f62e 15267 tp->pass_count = count;
6f6484cd 15268 observer_notify_breakpoint_modified (&tp->base);
197f0a60
TT
15269 if (from_tty)
15270 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
d9b3f62e 15271 tp->base.number, count);
197f0a60
TT
15272}
15273
1042e4c0
SS
15274/* Set passcount for tracepoint.
15275
15276 First command argument is passcount, second is tracepoint number.
15277 If tracepoint number omitted, apply to most recently defined.
15278 Also accepts special argument "all". */
15279
15280static void
15281trace_pass_command (char *args, int from_tty)
15282{
d9b3f62e 15283 struct tracepoint *t1;
1042e4c0 15284 unsigned int count;
1042e4c0
SS
15285
15286 if (args == 0 || *args == 0)
3e43a32a
MS
15287 error (_("passcount command requires an "
15288 "argument (count + optional TP num)"));
1042e4c0 15289
4a64f543 15290 count = strtoul (args, &args, 10); /* Count comes first, then TP num. */
1042e4c0 15291
529480d0 15292 args = skip_spaces (args);
1042e4c0
SS
15293 if (*args && strncasecmp (args, "all", 3) == 0)
15294 {
d9b3f62e
PA
15295 struct breakpoint *b;
15296
1042e4c0 15297 args += 3; /* Skip special argument "all". */
1042e4c0
SS
15298 if (*args)
15299 error (_("Junk at end of arguments."));
1042e4c0 15300
d9b3f62e 15301 ALL_TRACEPOINTS (b)
197f0a60 15302 {
d9b3f62e 15303 t1 = (struct tracepoint *) b;
197f0a60
TT
15304 trace_pass_set_count (t1, count, from_tty);
15305 }
15306 }
15307 else if (*args == '\0')
1042e4c0 15308 {
5fa1d40e 15309 t1 = get_tracepoint_by_number (&args, NULL);
1042e4c0 15310 if (t1)
197f0a60
TT
15311 trace_pass_set_count (t1, count, from_tty);
15312 }
15313 else
15314 {
15315 struct get_number_or_range_state state;
15316
15317 init_number_or_range (&state, args);
15318 while (!state.finished)
1042e4c0 15319 {
5fa1d40e 15320 t1 = get_tracepoint_by_number (&args, &state);
197f0a60
TT
15321 if (t1)
15322 trace_pass_set_count (t1, count, from_tty);
1042e4c0
SS
15323 }
15324 }
1042e4c0
SS
15325}
15326
d9b3f62e 15327struct tracepoint *
1042e4c0
SS
15328get_tracepoint (int num)
15329{
15330 struct breakpoint *t;
15331
15332 ALL_TRACEPOINTS (t)
15333 if (t->number == num)
d9b3f62e 15334 return (struct tracepoint *) t;
1042e4c0
SS
15335
15336 return NULL;
15337}
15338
d5551862
SS
15339/* Find the tracepoint with the given target-side number (which may be
15340 different from the tracepoint number after disconnecting and
15341 reconnecting). */
15342
d9b3f62e 15343struct tracepoint *
d5551862
SS
15344get_tracepoint_by_number_on_target (int num)
15345{
d9b3f62e 15346 struct breakpoint *b;
d5551862 15347
d9b3f62e
PA
15348 ALL_TRACEPOINTS (b)
15349 {
15350 struct tracepoint *t = (struct tracepoint *) b;
15351
15352 if (t->number_on_target == num)
15353 return t;
15354 }
d5551862
SS
15355
15356 return NULL;
15357}
15358
1042e4c0 15359/* Utility: parse a tracepoint number and look it up in the list.
197f0a60 15360 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
5fa1d40e
YQ
15361 If the argument is missing, the most recent tracepoint
15362 (tracepoint_count) is returned. */
15363
d9b3f62e 15364struct tracepoint *
197f0a60 15365get_tracepoint_by_number (char **arg,
5fa1d40e 15366 struct get_number_or_range_state *state)
1042e4c0 15367{
1042e4c0
SS
15368 struct breakpoint *t;
15369 int tpnum;
15370 char *instring = arg == NULL ? NULL : *arg;
15371
197f0a60
TT
15372 if (state)
15373 {
15374 gdb_assert (!state->finished);
15375 tpnum = get_number_or_range (state);
15376 }
15377 else if (arg == NULL || *arg == NULL || ! **arg)
5fa1d40e 15378 tpnum = tracepoint_count;
1042e4c0 15379 else
197f0a60 15380 tpnum = get_number (arg);
1042e4c0
SS
15381
15382 if (tpnum <= 0)
15383 {
15384 if (instring && *instring)
15385 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
15386 instring);
15387 else
5fa1d40e 15388 printf_filtered (_("No previous tracepoint\n"));
1042e4c0
SS
15389 return NULL;
15390 }
15391
15392 ALL_TRACEPOINTS (t)
15393 if (t->number == tpnum)
15394 {
d9b3f62e 15395 return (struct tracepoint *) t;
1042e4c0
SS
15396 }
15397
1042e4c0
SS
15398 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
15399 return NULL;
15400}
15401
d9b3f62e
PA
15402void
15403print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
15404{
15405 if (b->thread != -1)
15406 fprintf_unfiltered (fp, " thread %d", b->thread);
15407
15408 if (b->task != 0)
15409 fprintf_unfiltered (fp, " task %d", b->task);
15410
15411 fprintf_unfiltered (fp, "\n");
15412}
15413
6149aea9
PA
15414/* Save information on user settable breakpoints (watchpoints, etc) to
15415 a new script file named FILENAME. If FILTER is non-NULL, call it
15416 on each breakpoint and only include the ones for which it returns
15417 non-zero. */
15418
1042e4c0 15419static void
6149aea9
PA
15420save_breakpoints (char *filename, int from_tty,
15421 int (*filter) (const struct breakpoint *))
1042e4c0
SS
15422{
15423 struct breakpoint *tp;
6149aea9 15424 int any = 0;
1042e4c0 15425 struct cleanup *cleanup;
a7bdde9e 15426 struct ui_file *fp;
6149aea9 15427 int extra_trace_bits = 0;
1042e4c0 15428
6149aea9
PA
15429 if (filename == 0 || *filename == 0)
15430 error (_("Argument required (file name in which to save)"));
1042e4c0
SS
15431
15432 /* See if we have anything to save. */
6149aea9 15433 ALL_BREAKPOINTS (tp)
1042e4c0 15434 {
6149aea9 15435 /* Skip internal and momentary breakpoints. */
09d682a4 15436 if (!user_breakpoint_p (tp))
6149aea9
PA
15437 continue;
15438
15439 /* If we have a filter, only save the breakpoints it accepts. */
15440 if (filter && !filter (tp))
15441 continue;
15442
15443 any = 1;
15444
15445 if (is_tracepoint (tp))
15446 {
15447 extra_trace_bits = 1;
15448
15449 /* We can stop searching. */
15450 break;
15451 }
1042e4c0 15452 }
6149aea9
PA
15453
15454 if (!any)
1042e4c0 15455 {
6149aea9 15456 warning (_("Nothing to save."));
1042e4c0
SS
15457 return;
15458 }
15459
c718be47
PA
15460 filename = tilde_expand (filename);
15461 cleanup = make_cleanup (xfree, filename);
15462 fp = gdb_fopen (filename, "w");
059fb39f 15463 if (!fp)
6149aea9
PA
15464 error (_("Unable to open file '%s' for saving (%s)"),
15465 filename, safe_strerror (errno));
a7bdde9e 15466 make_cleanup_ui_file_delete (fp);
8bf6485c 15467
6149aea9
PA
15468 if (extra_trace_bits)
15469 save_trace_state_variables (fp);
8bf6485c 15470
6149aea9 15471 ALL_BREAKPOINTS (tp)
1042e4c0 15472 {
6149aea9 15473 /* Skip internal and momentary breakpoints. */
09d682a4 15474 if (!user_breakpoint_p (tp))
6149aea9 15475 continue;
8bf6485c 15476
6149aea9
PA
15477 /* If we have a filter, only save the breakpoints it accepts. */
15478 if (filter && !filter (tp))
15479 continue;
15480
348d480f 15481 tp->ops->print_recreate (tp, fp);
1042e4c0 15482
6149aea9
PA
15483 /* Note, we can't rely on tp->number for anything, as we can't
15484 assume the recreated breakpoint numbers will match. Use $bpnum
15485 instead. */
15486
15487 if (tp->cond_string)
15488 fprintf_unfiltered (fp, " condition $bpnum %s\n", tp->cond_string);
15489
15490 if (tp->ignore_count)
15491 fprintf_unfiltered (fp, " ignore $bpnum %d\n", tp->ignore_count);
15492
2d9442cc 15493 if (tp->type != bp_dprintf && tp->commands)
1042e4c0 15494 {
6c63c96a 15495 struct gdb_exception exception;
a7bdde9e 15496
6149aea9 15497 fprintf_unfiltered (fp, " commands\n");
a7bdde9e 15498
79a45e25 15499 ui_out_redirect (current_uiout, fp);
492d29ea 15500 TRY
1042e4c0 15501 {
79a45e25 15502 print_command_lines (current_uiout, tp->commands->commands, 2);
a7bdde9e 15503 }
492d29ea
PA
15504 CATCH (ex, RETURN_MASK_ALL)
15505 {
6c63c96a 15506 ui_out_redirect (current_uiout, NULL);
492d29ea
PA
15507 throw_exception (ex);
15508 }
15509 END_CATCH
1042e4c0 15510
6c63c96a 15511 ui_out_redirect (current_uiout, NULL);
a7bdde9e 15512 fprintf_unfiltered (fp, " end\n");
1042e4c0 15513 }
6149aea9
PA
15514
15515 if (tp->enable_state == bp_disabled)
99894e11 15516 fprintf_unfiltered (fp, "disable $bpnum\n");
6149aea9
PA
15517
15518 /* If this is a multi-location breakpoint, check if the locations
15519 should be individually disabled. Watchpoint locations are
15520 special, and not user visible. */
15521 if (!is_watchpoint (tp) && tp->loc && tp->loc->next)
15522 {
15523 struct bp_location *loc;
15524 int n = 1;
15525
15526 for (loc = tp->loc; loc != NULL; loc = loc->next, n++)
15527 if (!loc->enabled)
15528 fprintf_unfiltered (fp, "disable $bpnum.%d\n", n);
15529 }
1042e4c0 15530 }
8bf6485c 15531
6149aea9 15532 if (extra_trace_bits && *default_collect)
8bf6485c
SS
15533 fprintf_unfiltered (fp, "set default-collect %s\n", default_collect);
15534
1042e4c0 15535 if (from_tty)
6149aea9 15536 printf_filtered (_("Saved to file '%s'.\n"), filename);
c718be47 15537 do_cleanups (cleanup);
6149aea9
PA
15538}
15539
15540/* The `save breakpoints' command. */
15541
15542static void
15543save_breakpoints_command (char *args, int from_tty)
15544{
15545 save_breakpoints (args, from_tty, NULL);
15546}
15547
15548/* The `save tracepoints' command. */
15549
15550static void
15551save_tracepoints_command (char *args, int from_tty)
15552{
15553 save_breakpoints (args, from_tty, is_tracepoint);
1042e4c0
SS
15554}
15555
15556/* Create a vector of all tracepoints. */
15557
15558VEC(breakpoint_p) *
eeae04df 15559all_tracepoints (void)
1042e4c0
SS
15560{
15561 VEC(breakpoint_p) *tp_vec = 0;
15562 struct breakpoint *tp;
15563
15564 ALL_TRACEPOINTS (tp)
15565 {
15566 VEC_safe_push (breakpoint_p, tp_vec, tp);
15567 }
15568
15569 return tp_vec;
15570}
15571
c906108c 15572\f
629500fa
KS
15573/* This help string is used to consolidate all the help string for specifying
15574 locations used by several commands. */
15575
15576#define LOCATION_HELP_STRING \
15577"Linespecs are colon-separated lists of location parameters, such as\n\
15578source filename, function name, label name, and line number.\n\
15579Example: To specify the start of a label named \"the_top\" in the\n\
15580function \"fact\" in the file \"factorial.c\", use\n\
15581\"factorial.c:fact:the_top\".\n\
15582\n\
15583Address locations begin with \"*\" and specify an exact address in the\n\
15584program. Example: To specify the fourth byte past the start function\n\
15585\"main\", use \"*main + 4\".\n\
15586\n\
15587Explicit locations are similar to linespecs but use an option/argument\n\
15588syntax to specify location parameters.\n\
15589Example: To specify the start of the label named \"the_top\" in the\n\
15590function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15591-function fact -label the_top\".\n"
15592
4a64f543
MS
15593/* This help string is used for the break, hbreak, tbreak and thbreak
15594 commands. It is defined as a macro to prevent duplication.
15595 COMMAND should be a string constant containing the name of the
15596 command. */
629500fa 15597
31e2b00f 15598#define BREAK_ARGS_HELP(command) \
fb7b5af4
SDJ
15599command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM] [if CONDITION]\n\
15600PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15601probe point. Accepted values are `-probe' (for a generic, automatically\n\
d4777acb
JM
15602guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15603`-probe-dtrace' (for a DTrace probe).\n\
629500fa
KS
15604LOCATION may be a linespec, address, or explicit location as described\n\
15605below.\n\
15606\n\
dc10affe
PA
15607With no LOCATION, uses current execution address of the selected\n\
15608stack frame. This is useful for breaking on return to a stack frame.\n\
31e2b00f
AS
15609\n\
15610THREADNUM is the number from \"info threads\".\n\
15611CONDITION is a boolean expression.\n\
629500fa 15612\n" LOCATION_HELP_STRING "\n\
d41c0fc8
PA
15613Multiple breakpoints at one place are permitted, and useful if their\n\
15614conditions are different.\n\
31e2b00f
AS
15615\n\
15616Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15617
44feb3ce
TT
15618/* List of subcommands for "catch". */
15619static struct cmd_list_element *catch_cmdlist;
15620
15621/* List of subcommands for "tcatch". */
15622static struct cmd_list_element *tcatch_cmdlist;
15623
9ac4176b 15624void
44feb3ce 15625add_catch_command (char *name, char *docstring,
82ae6c8d 15626 cmd_sfunc_ftype *sfunc,
625e8578 15627 completer_ftype *completer,
44feb3ce
TT
15628 void *user_data_catch,
15629 void *user_data_tcatch)
15630{
15631 struct cmd_list_element *command;
15632
15633 command = add_cmd (name, class_breakpoint, NULL, docstring,
15634 &catch_cmdlist);
15635 set_cmd_sfunc (command, sfunc);
15636 set_cmd_context (command, user_data_catch);
a96d9b2e 15637 set_cmd_completer (command, completer);
44feb3ce
TT
15638
15639 command = add_cmd (name, class_breakpoint, NULL, docstring,
15640 &tcatch_cmdlist);
15641 set_cmd_sfunc (command, sfunc);
15642 set_cmd_context (command, user_data_tcatch);
a96d9b2e 15643 set_cmd_completer (command, completer);
44feb3ce
TT
15644}
15645
6149aea9
PA
15646static void
15647save_command (char *arg, int from_tty)
15648{
3e43a32a
MS
15649 printf_unfiltered (_("\"save\" must be followed by "
15650 "the name of a save subcommand.\n"));
635c7e8a 15651 help_list (save_cmdlist, "save ", all_commands, gdb_stdout);
6149aea9
PA
15652}
15653
84f4c1fe
PM
15654struct breakpoint *
15655iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
15656 void *data)
15657{
35df4500 15658 struct breakpoint *b, *b_tmp;
84f4c1fe 15659
35df4500 15660 ALL_BREAKPOINTS_SAFE (b, b_tmp)
84f4c1fe
PM
15661 {
15662 if ((*callback) (b, data))
15663 return b;
15664 }
15665
15666 return NULL;
15667}
15668
0574c78f
GB
15669/* Zero if any of the breakpoint's locations could be a location where
15670 functions have been inlined, nonzero otherwise. */
15671
15672static int
15673is_non_inline_function (struct breakpoint *b)
15674{
15675 /* The shared library event breakpoint is set on the address of a
15676 non-inline function. */
15677 if (b->type == bp_shlib_event)
15678 return 1;
15679
15680 return 0;
15681}
15682
15683/* Nonzero if the specified PC cannot be a location where functions
15684 have been inlined. */
15685
15686int
09ac7c10
TT
15687pc_at_non_inline_function (struct address_space *aspace, CORE_ADDR pc,
15688 const struct target_waitstatus *ws)
0574c78f
GB
15689{
15690 struct breakpoint *b;
15691 struct bp_location *bl;
15692
15693 ALL_BREAKPOINTS (b)
15694 {
15695 if (!is_non_inline_function (b))
15696 continue;
15697
15698 for (bl = b->loc; bl != NULL; bl = bl->next)
15699 {
15700 if (!bl->shlib_disabled
09ac7c10 15701 && bpstat_check_location (bl, aspace, pc, ws))
0574c78f
GB
15702 return 1;
15703 }
15704 }
15705
15706 return 0;
15707}
15708
2f202fde
JK
15709/* Remove any references to OBJFILE which is going to be freed. */
15710
15711void
15712breakpoint_free_objfile (struct objfile *objfile)
15713{
15714 struct bp_location **locp, *loc;
15715
15716 ALL_BP_LOCATIONS (loc, locp)
eb822aa6 15717 if (loc->symtab != NULL && SYMTAB_OBJFILE (loc->symtab) == objfile)
2f202fde
JK
15718 loc->symtab = NULL;
15719}
15720
2060206e
PA
15721void
15722initialize_breakpoint_ops (void)
15723{
15724 static int initialized = 0;
15725
15726 struct breakpoint_ops *ops;
15727
15728 if (initialized)
15729 return;
15730 initialized = 1;
15731
15732 /* The breakpoint_ops structure to be inherit by all kinds of
15733 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15734 internal and momentary breakpoints, etc.). */
15735 ops = &bkpt_base_breakpoint_ops;
15736 *ops = base_breakpoint_ops;
15737 ops->re_set = bkpt_re_set;
15738 ops->insert_location = bkpt_insert_location;
15739 ops->remove_location = bkpt_remove_location;
15740 ops->breakpoint_hit = bkpt_breakpoint_hit;
5f700d83 15741 ops->create_sals_from_location = bkpt_create_sals_from_location;
983af33b 15742 ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
5f700d83 15743 ops->decode_location = bkpt_decode_location;
2060206e
PA
15744
15745 /* The breakpoint_ops structure to be used in regular breakpoints. */
15746 ops = &bkpt_breakpoint_ops;
15747 *ops = bkpt_base_breakpoint_ops;
15748 ops->re_set = bkpt_re_set;
15749 ops->resources_needed = bkpt_resources_needed;
15750 ops->print_it = bkpt_print_it;
15751 ops->print_mention = bkpt_print_mention;
15752 ops->print_recreate = bkpt_print_recreate;
15753
15754 /* Ranged breakpoints. */
15755 ops = &ranged_breakpoint_ops;
15756 *ops = bkpt_breakpoint_ops;
15757 ops->breakpoint_hit = breakpoint_hit_ranged_breakpoint;
15758 ops->resources_needed = resources_needed_ranged_breakpoint;
15759 ops->print_it = print_it_ranged_breakpoint;
15760 ops->print_one = print_one_ranged_breakpoint;
15761 ops->print_one_detail = print_one_detail_ranged_breakpoint;
15762 ops->print_mention = print_mention_ranged_breakpoint;
15763 ops->print_recreate = print_recreate_ranged_breakpoint;
15764
15765 /* Internal breakpoints. */
15766 ops = &internal_breakpoint_ops;
15767 *ops = bkpt_base_breakpoint_ops;
15768 ops->re_set = internal_bkpt_re_set;
15769 ops->check_status = internal_bkpt_check_status;
15770 ops->print_it = internal_bkpt_print_it;
15771 ops->print_mention = internal_bkpt_print_mention;
15772
15773 /* Momentary breakpoints. */
15774 ops = &momentary_breakpoint_ops;
15775 *ops = bkpt_base_breakpoint_ops;
15776 ops->re_set = momentary_bkpt_re_set;
15777 ops->check_status = momentary_bkpt_check_status;
15778 ops->print_it = momentary_bkpt_print_it;
15779 ops->print_mention = momentary_bkpt_print_mention;
15780
e2e4d78b
JK
15781 /* Momentary breakpoints for bp_longjmp and bp_exception. */
15782 ops = &longjmp_breakpoint_ops;
15783 *ops = momentary_breakpoint_ops;
15784 ops->dtor = longjmp_bkpt_dtor;
15785
55aa24fb
SDJ
15786 /* Probe breakpoints. */
15787 ops = &bkpt_probe_breakpoint_ops;
15788 *ops = bkpt_breakpoint_ops;
15789 ops->insert_location = bkpt_probe_insert_location;
15790 ops->remove_location = bkpt_probe_remove_location;
5f700d83
KS
15791 ops->create_sals_from_location = bkpt_probe_create_sals_from_location;
15792 ops->decode_location = bkpt_probe_decode_location;
55aa24fb 15793
2060206e
PA
15794 /* Watchpoints. */
15795 ops = &watchpoint_breakpoint_ops;
15796 *ops = base_breakpoint_ops;
3a5c3e22 15797 ops->dtor = dtor_watchpoint;
2060206e
PA
15798 ops->re_set = re_set_watchpoint;
15799 ops->insert_location = insert_watchpoint;
15800 ops->remove_location = remove_watchpoint;
15801 ops->breakpoint_hit = breakpoint_hit_watchpoint;
15802 ops->check_status = check_status_watchpoint;
15803 ops->resources_needed = resources_needed_watchpoint;
15804 ops->works_in_software_mode = works_in_software_mode_watchpoint;
15805 ops->print_it = print_it_watchpoint;
15806 ops->print_mention = print_mention_watchpoint;
15807 ops->print_recreate = print_recreate_watchpoint;
427cd150 15808 ops->explains_signal = explains_signal_watchpoint;
2060206e
PA
15809
15810 /* Masked watchpoints. */
15811 ops = &masked_watchpoint_breakpoint_ops;
15812 *ops = watchpoint_breakpoint_ops;
15813 ops->insert_location = insert_masked_watchpoint;
15814 ops->remove_location = remove_masked_watchpoint;
15815 ops->resources_needed = resources_needed_masked_watchpoint;
15816 ops->works_in_software_mode = works_in_software_mode_masked_watchpoint;
15817 ops->print_it = print_it_masked_watchpoint;
15818 ops->print_one_detail = print_one_detail_masked_watchpoint;
15819 ops->print_mention = print_mention_masked_watchpoint;
15820 ops->print_recreate = print_recreate_masked_watchpoint;
15821
15822 /* Tracepoints. */
15823 ops = &tracepoint_breakpoint_ops;
15824 *ops = base_breakpoint_ops;
15825 ops->re_set = tracepoint_re_set;
15826 ops->breakpoint_hit = tracepoint_breakpoint_hit;
15827 ops->print_one_detail = tracepoint_print_one_detail;
15828 ops->print_mention = tracepoint_print_mention;
15829 ops->print_recreate = tracepoint_print_recreate;
5f700d83 15830 ops->create_sals_from_location = tracepoint_create_sals_from_location;
983af33b 15831 ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
5f700d83 15832 ops->decode_location = tracepoint_decode_location;
983af33b 15833
55aa24fb
SDJ
15834 /* Probe tracepoints. */
15835 ops = &tracepoint_probe_breakpoint_ops;
15836 *ops = tracepoint_breakpoint_ops;
5f700d83
KS
15837 ops->create_sals_from_location = tracepoint_probe_create_sals_from_location;
15838 ops->decode_location = tracepoint_probe_decode_location;
55aa24fb 15839
983af33b
SDJ
15840 /* Static tracepoints with marker (`-m'). */
15841 ops = &strace_marker_breakpoint_ops;
15842 *ops = tracepoint_breakpoint_ops;
5f700d83 15843 ops->create_sals_from_location = strace_marker_create_sals_from_location;
983af33b 15844 ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
5f700d83 15845 ops->decode_location = strace_marker_decode_location;
2060206e
PA
15846
15847 /* Fork catchpoints. */
15848 ops = &catch_fork_breakpoint_ops;
15849 *ops = base_breakpoint_ops;
15850 ops->insert_location = insert_catch_fork;
15851 ops->remove_location = remove_catch_fork;
15852 ops->breakpoint_hit = breakpoint_hit_catch_fork;
15853 ops->print_it = print_it_catch_fork;
15854 ops->print_one = print_one_catch_fork;
15855 ops->print_mention = print_mention_catch_fork;
15856 ops->print_recreate = print_recreate_catch_fork;
15857
15858 /* Vfork catchpoints. */
15859 ops = &catch_vfork_breakpoint_ops;
15860 *ops = base_breakpoint_ops;
15861 ops->insert_location = insert_catch_vfork;
15862 ops->remove_location = remove_catch_vfork;
15863 ops->breakpoint_hit = breakpoint_hit_catch_vfork;
15864 ops->print_it = print_it_catch_vfork;
15865 ops->print_one = print_one_catch_vfork;
15866 ops->print_mention = print_mention_catch_vfork;
15867 ops->print_recreate = print_recreate_catch_vfork;
15868
15869 /* Exec catchpoints. */
15870 ops = &catch_exec_breakpoint_ops;
15871 *ops = base_breakpoint_ops;
15872 ops->dtor = dtor_catch_exec;
15873 ops->insert_location = insert_catch_exec;
15874 ops->remove_location = remove_catch_exec;
15875 ops->breakpoint_hit = breakpoint_hit_catch_exec;
15876 ops->print_it = print_it_catch_exec;
15877 ops->print_one = print_one_catch_exec;
15878 ops->print_mention = print_mention_catch_exec;
15879 ops->print_recreate = print_recreate_catch_exec;
15880
edcc5120
TT
15881 /* Solib-related catchpoints. */
15882 ops = &catch_solib_breakpoint_ops;
15883 *ops = base_breakpoint_ops;
15884 ops->dtor = dtor_catch_solib;
15885 ops->insert_location = insert_catch_solib;
15886 ops->remove_location = remove_catch_solib;
15887 ops->breakpoint_hit = breakpoint_hit_catch_solib;
15888 ops->check_status = check_status_catch_solib;
15889 ops->print_it = print_it_catch_solib;
15890 ops->print_one = print_one_catch_solib;
15891 ops->print_mention = print_mention_catch_solib;
15892 ops->print_recreate = print_recreate_catch_solib;
e7e0cddf
SS
15893
15894 ops = &dprintf_breakpoint_ops;
15895 *ops = bkpt_base_breakpoint_ops;
5c2b4418 15896 ops->re_set = dprintf_re_set;
e7e0cddf
SS
15897 ops->resources_needed = bkpt_resources_needed;
15898 ops->print_it = bkpt_print_it;
15899 ops->print_mention = bkpt_print_mention;
2d9442cc 15900 ops->print_recreate = dprintf_print_recreate;
9d6e6e84 15901 ops->after_condition_true = dprintf_after_condition_true;
cd1608cc 15902 ops->breakpoint_hit = dprintf_breakpoint_hit;
2060206e
PA
15903}
15904
8bfd80db
YQ
15905/* Chain containing all defined "enable breakpoint" subcommands. */
15906
15907static struct cmd_list_element *enablebreaklist = NULL;
15908
c906108c 15909void
fba45db2 15910_initialize_breakpoint (void)
c906108c
SS
15911{
15912 struct cmd_list_element *c;
15913
2060206e
PA
15914 initialize_breakpoint_ops ();
15915
84acb35a 15916 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
63644780 15917 observer_attach_free_objfile (disable_breakpoints_in_freed_objfile);
1f3b5d1b 15918 observer_attach_memory_changed (invalidate_bp_value_on_memory_change);
84acb35a 15919
55aa24fb
SDJ
15920 breakpoint_objfile_key
15921 = register_objfile_data_with_cleanup (NULL, free_breakpoint_probes);
17450429 15922
c906108c
SS
15923 breakpoint_chain = 0;
15924 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15925 before a breakpoint is set. */
15926 breakpoint_count = 0;
15927
1042e4c0
SS
15928 tracepoint_count = 0;
15929
1bedd215
AC
15930 add_com ("ignore", class_breakpoint, ignore_command, _("\
15931Set ignore-count of breakpoint number N to COUNT.\n\
15932Usage is `ignore N COUNT'."));
c906108c 15933
1bedd215
AC
15934 add_com ("commands", class_breakpoint, commands_command, _("\
15935Set commands to be executed when a breakpoint is hit.\n\
c906108c
SS
15936Give breakpoint number as argument after \"commands\".\n\
15937With no argument, the targeted breakpoint is the last one set.\n\
15938The commands themselves follow starting on the next line.\n\
15939Type a line containing \"end\" to indicate the end of them.\n\
15940Give \"silent\" as the first line to make the breakpoint silent;\n\
1bedd215 15941then no output is printed when it is hit, except what the commands print."));
c906108c 15942
d55637df 15943 c = add_com ("condition", class_breakpoint, condition_command, _("\
1bedd215 15944Specify breakpoint number N to break only if COND is true.\n\
c906108c 15945Usage is `condition N COND', where N is an integer and COND is an\n\
1bedd215 15946expression to be evaluated whenever breakpoint N is reached."));
d55637df 15947 set_cmd_completer (c, condition_completer);
c906108c 15948
1bedd215 15949 c = add_com ("tbreak", class_breakpoint, tbreak_command, _("\
31e2b00f 15950Set a temporary breakpoint.\n\
c906108c
SS
15951Like \"break\" except the breakpoint is only temporary,\n\
15952so it will be deleted when hit. Equivalent to \"break\" followed\n\
31e2b00f
AS
15953by using \"enable delete\" on the breakpoint number.\n\
15954\n"
15955BREAK_ARGS_HELP ("tbreak")));
5ba2abeb 15956 set_cmd_completer (c, location_completer);
c94fdfd0 15957
1bedd215 15958 c = add_com ("hbreak", class_breakpoint, hbreak_command, _("\
a3be7890 15959Set a hardware assisted breakpoint.\n\
c906108c 15960Like \"break\" except the breakpoint requires hardware support,\n\
31e2b00f
AS
15961some target hardware may not have this support.\n\
15962\n"
15963BREAK_ARGS_HELP ("hbreak")));
5ba2abeb 15964 set_cmd_completer (c, location_completer);
c906108c 15965
1bedd215 15966 c = add_com ("thbreak", class_breakpoint, thbreak_command, _("\
31e2b00f 15967Set a temporary hardware assisted breakpoint.\n\
c906108c 15968Like \"hbreak\" except the breakpoint is only temporary,\n\
31e2b00f
AS
15969so it will be deleted when hit.\n\
15970\n"
15971BREAK_ARGS_HELP ("thbreak")));
5ba2abeb 15972 set_cmd_completer (c, location_completer);
c906108c 15973
1bedd215
AC
15974 add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
15975Enable some breakpoints.\n\
c906108c
SS
15976Give breakpoint numbers (separated by spaces) as arguments.\n\
15977With no subcommand, breakpoints are enabled until you command otherwise.\n\
15978This is used to cancel the effect of the \"disable\" command.\n\
1bedd215 15979With a subcommand you can enable temporarily."),
c906108c 15980 &enablelist, "enable ", 1, &cmdlist);
c906108c
SS
15981
15982 add_com_alias ("en", "enable", class_breakpoint, 1);
15983
84951ab5 15984 add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
1bedd215 15985Enable some breakpoints.\n\
c906108c
SS
15986Give breakpoint numbers (separated by spaces) as arguments.\n\
15987This is used to cancel the effect of the \"disable\" command.\n\
1bedd215 15988May be abbreviated to simply \"enable\".\n"),
c5aa993b 15989 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
c906108c 15990
1a966eab
AC
15991 add_cmd ("once", no_class, enable_once_command, _("\
15992Enable breakpoints for one hit. Give breakpoint numbers.\n\
15993If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
c906108c
SS
15994 &enablebreaklist);
15995
1a966eab
AC
15996 add_cmd ("delete", no_class, enable_delete_command, _("\
15997Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
15998If a breakpoint is hit while enabled in this fashion, it is deleted."),
c906108c
SS
15999 &enablebreaklist);
16000
816338b5
SS
16001 add_cmd ("count", no_class, enable_count_command, _("\
16002Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16003If a breakpoint is hit while enabled in this fashion,\n\
16004the count is decremented; when it reaches zero, the breakpoint is disabled."),
16005 &enablebreaklist);
16006
1a966eab
AC
16007 add_cmd ("delete", no_class, enable_delete_command, _("\
16008Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
16009If a breakpoint is hit while enabled in this fashion, it is deleted."),
c906108c
SS
16010 &enablelist);
16011
1a966eab
AC
16012 add_cmd ("once", no_class, enable_once_command, _("\
16013Enable breakpoints for one hit. Give breakpoint numbers.\n\
16014If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
816338b5
SS
16015 &enablelist);
16016
16017 add_cmd ("count", no_class, enable_count_command, _("\
16018Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
16019If a breakpoint is hit while enabled in this fashion,\n\
16020the count is decremented; when it reaches zero, the breakpoint is disabled."),
c906108c
SS
16021 &enablelist);
16022
1bedd215
AC
16023 add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
16024Disable some breakpoints.\n\
c906108c
SS
16025Arguments are breakpoint numbers with spaces in between.\n\
16026To disable all breakpoints, give no argument.\n\
64b9b334 16027A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
c906108c
SS
16028 &disablelist, "disable ", 1, &cmdlist);
16029 add_com_alias ("dis", "disable", class_breakpoint, 1);
16030 add_com_alias ("disa", "disable", class_breakpoint, 1);
c906108c 16031
1a966eab
AC
16032 add_cmd ("breakpoints", class_alias, disable_command, _("\
16033Disable some breakpoints.\n\
c906108c
SS
16034Arguments are breakpoint numbers with spaces in between.\n\
16035To disable all breakpoints, give no argument.\n\
64b9b334 16036A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
1a966eab 16037This command may be abbreviated \"disable\"."),
c906108c
SS
16038 &disablelist);
16039
1bedd215
AC
16040 add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
16041Delete some breakpoints or auto-display expressions.\n\
c906108c
SS
16042Arguments are breakpoint numbers with spaces in between.\n\
16043To delete all breakpoints, give no argument.\n\
16044\n\
16045Also a prefix command for deletion of other GDB objects.\n\
1bedd215 16046The \"unset\" command is also an alias for \"delete\"."),
c906108c
SS
16047 &deletelist, "delete ", 1, &cmdlist);
16048 add_com_alias ("d", "delete", class_breakpoint, 1);
7f198e01 16049 add_com_alias ("del", "delete", class_breakpoint, 1);
c906108c 16050
1a966eab
AC
16051 add_cmd ("breakpoints", class_alias, delete_command, _("\
16052Delete some breakpoints or auto-display expressions.\n\
c906108c
SS
16053Arguments are breakpoint numbers with spaces in between.\n\
16054To delete all breakpoints, give no argument.\n\
1a966eab 16055This command may be abbreviated \"delete\"."),
c906108c
SS
16056 &deletelist);
16057
1bedd215 16058 add_com ("clear", class_breakpoint, clear_command, _("\
629500fa
KS
16059Clear breakpoint at specified location.\n\
16060Argument may be a linespec, explicit, or address location as described below.\n\
1bedd215
AC
16061\n\
16062With no argument, clears all breakpoints in the line that the selected frame\n\
629500fa
KS
16063is executing in.\n"
16064"\n" LOCATION_HELP_STRING "\n\
1bedd215 16065See also the \"delete\" command which clears breakpoints by number."));
a6cc4789 16066 add_com_alias ("cl", "clear", class_breakpoint, 1);
c906108c 16067
1bedd215 16068 c = add_com ("break", class_breakpoint, break_command, _("\
629500fa 16069Set breakpoint at specified location.\n"
31e2b00f 16070BREAK_ARGS_HELP ("break")));
5ba2abeb 16071 set_cmd_completer (c, location_completer);
c94fdfd0 16072
c906108c
SS
16073 add_com_alias ("b", "break", class_run, 1);
16074 add_com_alias ("br", "break", class_run, 1);
16075 add_com_alias ("bre", "break", class_run, 1);
16076 add_com_alias ("brea", "break", class_run, 1);
16077
c906108c
SS
16078 if (dbx_commands)
16079 {
1bedd215
AC
16080 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, _("\
16081Break in function/address or break at a line in the current file."),
c5aa993b
JM
16082 &stoplist, "stop ", 1, &cmdlist);
16083 add_cmd ("in", class_breakpoint, stopin_command,
1a966eab 16084 _("Break in function or address."), &stoplist);
c5aa993b 16085 add_cmd ("at", class_breakpoint, stopat_command,
1a966eab 16086 _("Break at a line in the current file."), &stoplist);
1bedd215
AC
16087 add_com ("status", class_info, breakpoints_info, _("\
16088Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
c906108c
SS
16089The \"Type\" column indicates one of:\n\
16090\tbreakpoint - normal breakpoint\n\
16091\twatchpoint - watchpoint\n\
16092The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16093the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16094breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
1bedd215
AC
16095address and file/line number respectively.\n\
16096\n\
16097Convenience variable \"$_\" and default examine address for \"x\"\n\
d1aa2f50
NR
16098are set to the address of the last breakpoint listed unless the command\n\
16099is prefixed with \"server \".\n\n\
c906108c 16100Convenience variable \"$bpnum\" contains the number of the last\n\
1bedd215 16101breakpoint set."));
c906108c
SS
16102 }
16103
1bedd215 16104 add_info ("breakpoints", breakpoints_info, _("\
e5a67952 16105Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
c906108c
SS
16106The \"Type\" column indicates one of:\n\
16107\tbreakpoint - normal breakpoint\n\
16108\twatchpoint - watchpoint\n\
16109The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
16110the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16111breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
1bedd215
AC
16112address and file/line number respectively.\n\
16113\n\
16114Convenience variable \"$_\" and default examine address for \"x\"\n\
d1aa2f50
NR
16115are set to the address of the last breakpoint listed unless the command\n\
16116is prefixed with \"server \".\n\n\
c906108c 16117Convenience variable \"$bpnum\" contains the number of the last\n\
1bedd215 16118breakpoint set."));
c906108c 16119
6b04bdb7
MS
16120 add_info_alias ("b", "breakpoints", 1);
16121
1a966eab
AC
16122 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, _("\
16123Status of all breakpoints, or breakpoint number NUMBER.\n\
c906108c
SS
16124The \"Type\" column indicates one of:\n\
16125\tbreakpoint - normal breakpoint\n\
16126\twatchpoint - watchpoint\n\
16127\tlongjmp - internal breakpoint used to step through longjmp()\n\
16128\tlongjmp resume - internal breakpoint at the target of longjmp()\n\
16129\tuntil - internal breakpoint used by the \"until\" command\n\
1a966eab
AC
16130\tfinish - internal breakpoint used by the \"finish\" command\n\
16131The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
c906108c
SS
16132the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
16133breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
1a966eab
AC
16134address and file/line number respectively.\n\
16135\n\
16136Convenience variable \"$_\" and default examine address for \"x\"\n\
d1aa2f50
NR
16137are set to the address of the last breakpoint listed unless the command\n\
16138is prefixed with \"server \".\n\n\
c906108c 16139Convenience variable \"$bpnum\" contains the number of the last\n\
1a966eab 16140breakpoint set."),
c906108c
SS
16141 &maintenanceinfolist);
16142
44feb3ce
TT
16143 add_prefix_cmd ("catch", class_breakpoint, catch_command, _("\
16144Set catchpoints to catch events."),
16145 &catch_cmdlist, "catch ",
16146 0/*allow-unknown*/, &cmdlist);
16147
16148 add_prefix_cmd ("tcatch", class_breakpoint, tcatch_command, _("\
16149Set temporary catchpoints to catch events."),
16150 &tcatch_cmdlist, "tcatch ",
16151 0/*allow-unknown*/, &cmdlist);
16152
44feb3ce
TT
16153 add_catch_command ("fork", _("Catch calls to fork."),
16154 catch_fork_command_1,
a96d9b2e 16155 NULL,
44feb3ce
TT
16156 (void *) (uintptr_t) catch_fork_permanent,
16157 (void *) (uintptr_t) catch_fork_temporary);
16158 add_catch_command ("vfork", _("Catch calls to vfork."),
16159 catch_fork_command_1,
a96d9b2e 16160 NULL,
44feb3ce
TT
16161 (void *) (uintptr_t) catch_vfork_permanent,
16162 (void *) (uintptr_t) catch_vfork_temporary);
16163 add_catch_command ("exec", _("Catch calls to exec."),
16164 catch_exec_command_1,
a96d9b2e
SDJ
16165 NULL,
16166 CATCH_PERMANENT,
16167 CATCH_TEMPORARY);
edcc5120
TT
16168 add_catch_command ("load", _("Catch loads of shared libraries.\n\
16169Usage: catch load [REGEX]\n\
16170If REGEX is given, only stop for libraries matching the regular expression."),
16171 catch_load_command_1,
16172 NULL,
16173 CATCH_PERMANENT,
16174 CATCH_TEMPORARY);
16175 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
16176Usage: catch unload [REGEX]\n\
16177If REGEX is given, only stop for libraries matching the regular expression."),
16178 catch_unload_command_1,
16179 NULL,
16180 CATCH_PERMANENT,
16181 CATCH_TEMPORARY);
c5aa993b 16182
1bedd215
AC
16183 c = add_com ("watch", class_breakpoint, watch_command, _("\
16184Set a watchpoint for an expression.\n\
06a64a0b 16185Usage: watch [-l|-location] EXPRESSION\n\
c906108c 16186A watchpoint stops execution of your program whenever the value of\n\
06a64a0b
TT
16187an expression changes.\n\
16188If -l or -location is given, this evaluates EXPRESSION and watches\n\
16189the memory to which it refers."));
65d12d83 16190 set_cmd_completer (c, expression_completer);
c906108c 16191
1bedd215
AC
16192 c = add_com ("rwatch", class_breakpoint, rwatch_command, _("\
16193Set a read watchpoint for an expression.\n\
06a64a0b 16194Usage: rwatch [-l|-location] EXPRESSION\n\
c906108c 16195A watchpoint stops execution of your program whenever the value of\n\
06a64a0b
TT
16196an expression is read.\n\
16197If -l or -location is given, this evaluates EXPRESSION and watches\n\
16198the memory to which it refers."));
65d12d83 16199 set_cmd_completer (c, expression_completer);
c906108c 16200
1bedd215
AC
16201 c = add_com ("awatch", class_breakpoint, awatch_command, _("\
16202Set a watchpoint for an expression.\n\
06a64a0b 16203Usage: awatch [-l|-location] EXPRESSION\n\
c906108c 16204A watchpoint stops execution of your program whenever the value of\n\
06a64a0b
TT
16205an expression is either read or written.\n\
16206If -l or -location is given, this evaluates EXPRESSION and watches\n\
16207the memory to which it refers."));
65d12d83 16208 set_cmd_completer (c, expression_completer);
c906108c 16209
d77f58be 16210 add_info ("watchpoints", watchpoints_info, _("\
e5a67952 16211Status of specified watchpoints (all watchpoints if no argument)."));
c906108c 16212
920d2a44
AC
16213 /* XXX: cagney/2005-02-23: This should be a boolean, and should
16214 respond to changes - contrary to the description. */
85c07804
AC
16215 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support,
16216 &can_use_hw_watchpoints, _("\
16217Set debugger's willingness to use watchpoint hardware."), _("\
16218Show debugger's willingness to use watchpoint hardware."), _("\
c906108c
SS
16219If zero, gdb will not use hardware for new watchpoints, even if\n\
16220such is available. (However, any hardware watchpoints that were\n\
16221created before setting this to nonzero, will continue to use watchpoint\n\
85c07804
AC
16222hardware.)"),
16223 NULL,
920d2a44 16224 show_can_use_hw_watchpoints,
85c07804 16225 &setlist, &showlist);
c906108c
SS
16226
16227 can_use_hw_watchpoints = 1;
fa8d40ab 16228
1042e4c0
SS
16229 /* Tracepoint manipulation commands. */
16230
16231 c = add_com ("trace", class_breakpoint, trace_command, _("\
629500fa 16232Set a tracepoint at specified location.\n\
1042e4c0
SS
16233\n"
16234BREAK_ARGS_HELP ("trace") "\n\
16235Do \"help tracepoints\" for info on other tracepoint commands."));
16236 set_cmd_completer (c, location_completer);
16237
16238 add_com_alias ("tp", "trace", class_alias, 0);
16239 add_com_alias ("tr", "trace", class_alias, 1);
16240 add_com_alias ("tra", "trace", class_alias, 1);
16241 add_com_alias ("trac", "trace", class_alias, 1);
16242
7a697b8d 16243 c = add_com ("ftrace", class_breakpoint, ftrace_command, _("\
629500fa 16244Set a fast tracepoint at specified location.\n\
7a697b8d
SS
16245\n"
16246BREAK_ARGS_HELP ("ftrace") "\n\
16247Do \"help tracepoints\" for info on other tracepoint commands."));
16248 set_cmd_completer (c, location_completer);
16249
0fb4aa4b 16250 c = add_com ("strace", class_breakpoint, strace_command, _("\
629500fa 16251Set a static tracepoint at location or marker.\n\
0fb4aa4b
PA
16252\n\
16253strace [LOCATION] [if CONDITION]\n\
629500fa
KS
16254LOCATION may be a linespec, explicit, or address location (described below) \n\
16255or -m MARKER_ID.\n\n\
16256If a marker id is specified, probe the marker with that name. With\n\
16257no LOCATION, uses current execution address of the selected stack frame.\n\
0fb4aa4b
PA
16258Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
16259This collects arbitrary user data passed in the probe point call to the\n\
16260tracing library. You can inspect it when analyzing the trace buffer,\n\
16261by printing the $_sdata variable like any other convenience variable.\n\
16262\n\
16263CONDITION is a boolean expression.\n\
629500fa 16264\n" LOCATION_HELP_STRING "\n\
d41c0fc8
PA
16265Multiple tracepoints at one place are permitted, and useful if their\n\
16266conditions are different.\n\
0fb4aa4b
PA
16267\n\
16268Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
16269Do \"help tracepoints\" for info on other tracepoint commands."));
16270 set_cmd_completer (c, location_completer);
16271
1042e4c0 16272 add_info ("tracepoints", tracepoints_info, _("\
e5a67952 16273Status of specified tracepoints (all tracepoints if no argument).\n\
1042e4c0
SS
16274Convenience variable \"$tpnum\" contains the number of the\n\
16275last tracepoint set."));
16276
16277 add_info_alias ("tp", "tracepoints", 1);
16278
16279 add_cmd ("tracepoints", class_trace, delete_trace_command, _("\
16280Delete specified tracepoints.\n\
16281Arguments are tracepoint numbers, separated by spaces.\n\
16282No argument means delete all tracepoints."),
16283 &deletelist);
7e20dfcd 16284 add_alias_cmd ("tr", "tracepoints", class_trace, 1, &deletelist);
1042e4c0
SS
16285
16286 c = add_cmd ("tracepoints", class_trace, disable_trace_command, _("\
16287Disable specified tracepoints.\n\
16288Arguments are tracepoint numbers, separated by spaces.\n\
16289No argument means disable all tracepoints."),
16290 &disablelist);
16291 deprecate_cmd (c, "disable");
16292
16293 c = add_cmd ("tracepoints", class_trace, enable_trace_command, _("\
16294Enable specified tracepoints.\n\
16295Arguments are tracepoint numbers, separated by spaces.\n\
16296No argument means enable all tracepoints."),
16297 &enablelist);
16298 deprecate_cmd (c, "enable");
16299
16300 add_com ("passcount", class_trace, trace_pass_command, _("\
16301Set the passcount for a tracepoint.\n\
16302The trace will end when the tracepoint has been passed 'count' times.\n\
16303Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
16304if TPNUM is omitted, passcount refers to the last tracepoint defined."));
16305
6149aea9
PA
16306 add_prefix_cmd ("save", class_breakpoint, save_command,
16307 _("Save breakpoint definitions as a script."),
16308 &save_cmdlist, "save ",
16309 0/*allow-unknown*/, &cmdlist);
16310
16311 c = add_cmd ("breakpoints", class_breakpoint, save_breakpoints_command, _("\
16312Save current breakpoint definitions as a script.\n\
cce7e648 16313This includes all types of breakpoints (breakpoints, watchpoints,\n\
6149aea9
PA
16314catchpoints, tracepoints). Use the 'source' command in another debug\n\
16315session to restore them."),
16316 &save_cmdlist);
16317 set_cmd_completer (c, filename_completer);
16318
16319 c = add_cmd ("tracepoints", class_trace, save_tracepoints_command, _("\
1042e4c0 16320Save current tracepoint definitions as a script.\n\
6149aea9
PA
16321Use the 'source' command in another debug session to restore them."),
16322 &save_cmdlist);
1042e4c0
SS
16323 set_cmd_completer (c, filename_completer);
16324
6149aea9
PA
16325 c = add_com_alias ("save-tracepoints", "save tracepoints", class_trace, 0);
16326 deprecate_cmd (c, "save tracepoints");
16327
1bedd215 16328 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
fa8d40ab
JJ
16329Breakpoint specific settings\n\
16330Configure various breakpoint-specific variables such as\n\
1bedd215 16331pending breakpoint behavior"),
fa8d40ab
JJ
16332 &breakpoint_set_cmdlist, "set breakpoint ",
16333 0/*allow-unknown*/, &setlist);
1bedd215 16334 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
fa8d40ab
JJ
16335Breakpoint specific settings\n\
16336Configure various breakpoint-specific variables such as\n\
1bedd215 16337pending breakpoint behavior"),
fa8d40ab
JJ
16338 &breakpoint_show_cmdlist, "show breakpoint ",
16339 0/*allow-unknown*/, &showlist);
16340
7915a72c
AC
16341 add_setshow_auto_boolean_cmd ("pending", no_class,
16342 &pending_break_support, _("\
16343Set debugger's behavior regarding pending breakpoints."), _("\
16344Show debugger's behavior regarding pending breakpoints."), _("\
6e1d7d6c
AC
16345If on, an unrecognized breakpoint location will cause gdb to create a\n\
16346pending breakpoint. If off, an unrecognized breakpoint location results in\n\
16347an error. If auto, an unrecognized breakpoint location results in a\n\
7915a72c 16348user-query to see if a pending breakpoint should be created."),
2c5b56ce 16349 NULL,
920d2a44 16350 show_pending_break_support,
6e1d7d6c
AC
16351 &breakpoint_set_cmdlist,
16352 &breakpoint_show_cmdlist);
fa8d40ab
JJ
16353
16354 pending_break_support = AUTO_BOOLEAN_AUTO;
765dc015
VP
16355
16356 add_setshow_boolean_cmd ("auto-hw", no_class,
16357 &automatic_hardware_breakpoints, _("\
16358Set automatic usage of hardware breakpoints."), _("\
16359Show automatic usage of hardware breakpoints."), _("\
16360If set, the debugger will automatically use hardware breakpoints for\n\
16361breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
16362a warning will be emitted for such breakpoints."),
16363 NULL,
16364 show_automatic_hardware_breakpoints,
16365 &breakpoint_set_cmdlist,
16366 &breakpoint_show_cmdlist);
74960c60 16367
a25a5a45
PA
16368 add_setshow_boolean_cmd ("always-inserted", class_support,
16369 &always_inserted_mode, _("\
74960c60
VP
16370Set mode for inserting breakpoints."), _("\
16371Show mode for inserting breakpoints."), _("\
a25a5a45
PA
16372When this mode is on, breakpoints are inserted immediately as soon as\n\
16373they're created, kept inserted even when execution stops, and removed\n\
16374only when the user deletes them. When this mode is off (the default),\n\
16375breakpoints are inserted only when execution continues, and removed\n\
16376when execution stops."),
72d0e2c5
YQ
16377 NULL,
16378 &show_always_inserted_mode,
16379 &breakpoint_set_cmdlist,
16380 &breakpoint_show_cmdlist);
f1310107 16381
b775012e
LM
16382 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
16383 condition_evaluation_enums,
16384 &condition_evaluation_mode_1, _("\
16385Set mode of breakpoint condition evaluation."), _("\
16386Show mode of breakpoint condition evaluation."), _("\
d1cda5d9 16387When this is set to \"host\", breakpoint conditions will be\n\
b775012e
LM
16388evaluated on the host's side by GDB. When it is set to \"target\",\n\
16389breakpoint conditions will be downloaded to the target (if the target\n\
16390supports such feature) and conditions will be evaluated on the target's side.\n\
16391If this is set to \"auto\" (default), this will be automatically set to\n\
16392\"target\" if it supports condition evaluation, otherwise it will\n\
16393be set to \"gdb\""),
16394 &set_condition_evaluation_mode,
16395 &show_condition_evaluation_mode,
16396 &breakpoint_set_cmdlist,
16397 &breakpoint_show_cmdlist);
16398
f1310107
TJB
16399 add_com ("break-range", class_breakpoint, break_range_command, _("\
16400Set a breakpoint for an address range.\n\
16401break-range START-LOCATION, END-LOCATION\n\
16402where START-LOCATION and END-LOCATION can be one of the following:\n\
16403 LINENUM, for that line in the current file,\n\
16404 FILE:LINENUM, for that line in that file,\n\
16405 +OFFSET, for that number of lines after the current line\n\
16406 or the start of the range\n\
16407 FUNCTION, for the first line in that function,\n\
16408 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16409 *ADDRESS, for the instruction at that address.\n\
16410\n\
16411The breakpoint will stop execution of the inferior whenever it executes\n\
16412an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16413range (including START-LOCATION and END-LOCATION)."));
16414
e7e0cddf 16415 c = add_com ("dprintf", class_breakpoint, dprintf_command, _("\
629500fa 16416Set a dynamic printf at specified location.\n\
e7e0cddf 16417dprintf location,format string,arg1,arg2,...\n\
629500fa
KS
16418location may be a linespec, explicit, or address location.\n"
16419"\n" LOCATION_HELP_STRING));
e7e0cddf
SS
16420 set_cmd_completer (c, location_completer);
16421
16422 add_setshow_enum_cmd ("dprintf-style", class_support,
16423 dprintf_style_enums, &dprintf_style, _("\
16424Set the style of usage for dynamic printf."), _("\
16425Show the style of usage for dynamic printf."), _("\
16426This setting chooses how GDB will do a dynamic printf.\n\
16427If the value is \"gdb\", then the printing is done by GDB to its own\n\
16428console, as with the \"printf\" command.\n\
16429If the value is \"call\", the print is done by calling a function in your\n\
16430program; by default printf(), but you can choose a different function or\n\
16431output stream by setting dprintf-function and dprintf-channel."),
16432 update_dprintf_commands, NULL,
16433 &setlist, &showlist);
16434
16435 dprintf_function = xstrdup ("printf");
16436 add_setshow_string_cmd ("dprintf-function", class_support,
16437 &dprintf_function, _("\
16438Set the function to use for dynamic printf"), _("\
16439Show the function to use for dynamic printf"), NULL,
16440 update_dprintf_commands, NULL,
16441 &setlist, &showlist);
16442
16443 dprintf_channel = xstrdup ("");
16444 add_setshow_string_cmd ("dprintf-channel", class_support,
16445 &dprintf_channel, _("\
16446Set the channel to use for dynamic printf"), _("\
16447Show the channel to use for dynamic printf"), NULL,
16448 update_dprintf_commands, NULL,
16449 &setlist, &showlist);
16450
d3ce09f5
SS
16451 add_setshow_boolean_cmd ("disconnected-dprintf", no_class,
16452 &disconnected_dprintf, _("\
16453Set whether dprintf continues after GDB disconnects."), _("\
16454Show whether dprintf continues after GDB disconnects."), _("\
16455Use this to let dprintf commands continue to hit and produce output\n\
16456even if GDB disconnects or detaches from the target."),
16457 NULL,
16458 NULL,
16459 &setlist, &showlist);
16460
16461 add_com ("agent-printf", class_vars, agent_printf_command, _("\
16462agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
16463(target agent only) This is useful for formatted output in user-defined commands."));
16464
765dc015 16465 automatic_hardware_breakpoints = 1;
f3b1572e
PA
16466
16467 observer_attach_about_to_proceed (breakpoint_about_to_proceed);
49fa26b0 16468 observer_attach_thread_exit (remove_threaded_breakpoints);
c906108c 16469}
This page took 2.942182 seconds and 4 git commands to generate.