2005-01-14 H.J. Lu <hongjiu.lu@intel.com>
[deliverable/binutils-gdb.git] / gdb / breakpoint.c
CommitLineData
c906108c 1/* Everything about breakpoints, for GDB.
8926118c
AC
2
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
05ff989b 4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
e74f0f02 5 Free Software Foundation, Inc.
c906108c 6
c5aa993b 7 This file is part of GDB.
c906108c 8
c5aa993b
JM
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
c906108c 13
c5aa993b
JM
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
c906108c 18
c5aa993b
JM
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
c906108c
SS
23
24#include "defs.h"
25#include <ctype.h>
26#include "symtab.h"
27#include "frame.h"
28#include "breakpoint.h"
29#include "gdbtypes.h"
30#include "expression.h"
31#include "gdbcore.h"
32#include "gdbcmd.h"
33#include "value.h"
34#include "command.h"
35#include "inferior.h"
36#include "gdbthread.h"
37#include "target.h"
38#include "language.h"
39#include "gdb_string.h"
40#include "demangle.h"
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"
0225421b 50#include "gdb_assert.h"
fe898f56 51#include "block.h"
84acb35a
JJ
52#include "solist.h"
53#include "observer.h"
60250e8b 54#include "exceptions.h"
c906108c 55
104c1213
JM
56#include "gdb-events.h"
57
c906108c
SS
58/* Prototypes for local functions. */
59
c2c6d25f
JM
60static void until_break_command_continuation (struct continuation_arg *arg);
61
a14ed312 62static void catch_command_1 (char *, int, int);
c906108c 63
a14ed312 64static void enable_delete_command (char *, int);
c906108c 65
a14ed312 66static void enable_delete_breakpoint (struct breakpoint *);
c906108c 67
a14ed312 68static void enable_once_command (char *, int);
c906108c 69
a14ed312 70static void enable_once_breakpoint (struct breakpoint *);
c906108c 71
a14ed312 72static void disable_command (char *, int);
c906108c 73
a14ed312 74static void enable_command (char *, int);
c906108c 75
a14ed312 76static void map_breakpoint_numbers (char *, void (*)(struct breakpoint *));
c906108c 77
a14ed312 78static void ignore_command (char *, int);
c906108c 79
4efb68b1 80static int breakpoint_re_set_one (void *);
c906108c 81
a14ed312 82static void clear_command (char *, int);
c906108c 83
a14ed312 84static void catch_command (char *, int);
c906108c 85
a14ed312 86static void watch_command (char *, int);
c906108c 87
a14ed312 88static int can_use_hardware_watchpoint (struct value *);
c906108c 89
0101ce28 90static int break_command_1 (char *, int, int, struct breakpoint *);
c906108c 91
a14ed312 92static void mention (struct breakpoint *);
c906108c 93
4d28f7a8 94struct breakpoint *set_raw_breakpoint (struct symtab_and_line, enum bptype);
c906108c 95
9f60f21b 96static void check_duplicates (struct breakpoint *);
c906108c 97
76897487
KB
98static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
99
88f7da05
KB
100static CORE_ADDR adjust_breakpoint_address (CORE_ADDR bpaddr,
101 enum bptype bptype);
76897487 102
a14ed312 103static void describe_other_breakpoints (CORE_ADDR, asection *);
c906108c 104
a14ed312 105static void breakpoints_info (char *, int);
c906108c 106
a14ed312 107static void breakpoint_1 (int, int);
c906108c 108
a14ed312 109static bpstat bpstat_alloc (struct breakpoint *, bpstat);
c906108c 110
4efb68b1 111static int breakpoint_cond_eval (void *);
c906108c 112
4efb68b1 113static void cleanup_executing_breakpoints (void *);
c906108c 114
a14ed312 115static void commands_command (char *, int);
c906108c 116
a14ed312 117static void condition_command (char *, int);
c906108c 118
a14ed312 119static int get_number_trailer (char **, int);
c906108c 120
a14ed312 121void set_breakpoint_count (int);
c906108c 122
c5aa993b
JM
123typedef enum
124 {
125 mark_inserted,
126 mark_uninserted
127 }
128insertion_state_t;
c906108c 129
0bde7532 130static int remove_breakpoint (struct bp_location *, insertion_state_t);
c906108c 131
a14ed312 132static enum print_stop_action print_it_typical (bpstat);
e514a9d6
JM
133
134static enum print_stop_action print_bp_stop_message (bpstat bs);
c906108c 135
c5aa993b
JM
136typedef struct
137 {
138 enum exception_event_kind kind;
b5de0fa7 139 int enable_p;
c5aa993b
JM
140 }
141args_for_catchpoint_enable;
c906108c 142
4efb68b1 143static int watchpoint_check (void *);
c906108c 144
4efb68b1 145static int cover_target_enable_exception_callback (void *);
c906108c 146
a14ed312 147static void maintenance_info_breakpoints (char *, int);
c906108c 148
a14ed312 149static void create_longjmp_breakpoint (char *);
c906108c 150
1900040c
MS
151static void create_overlay_event_breakpoint (char *);
152
a14ed312 153static int hw_breakpoint_used_count (void);
c906108c 154
a14ed312 155static int hw_watchpoint_used_count (enum bptype, int *);
c906108c 156
a14ed312 157static void hbreak_command (char *, int);
c906108c 158
a14ed312 159static void thbreak_command (char *, int);
c906108c 160
a14ed312 161static void watch_command_1 (char *, int, int);
c906108c 162
a14ed312 163static void rwatch_command (char *, int);
c906108c 164
a14ed312 165static void awatch_command (char *, int);
c906108c 166
a14ed312 167static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
c906108c 168
a14ed312
KB
169static void solib_load_unload_1 (char *hookname,
170 int tempflag,
171 char *dll_pathname,
172 char *cond_string, enum bptype bp_kind);
7a292a7a 173
a14ed312
KB
174static void create_fork_vfork_event_catchpoint (int tempflag,
175 char *cond_string,
176 enum bptype bp_kind);
7a292a7a 177
a14ed312 178static void stop_command (char *arg, int from_tty);
7a292a7a 179
a14ed312 180static void stopin_command (char *arg, int from_tty);
7a292a7a 181
a14ed312 182static void stopat_command (char *arg, int from_tty);
7a292a7a 183
a14ed312 184static char *ep_find_event_name_end (char *arg);
7a292a7a 185
a14ed312 186static char *ep_parse_optional_if_clause (char **arg);
7a292a7a 187
a14ed312 188static char *ep_parse_optional_filename (char **arg);
7a292a7a 189
d85310f7
MS
190static void create_exception_catchpoint (int tempflag, char *cond_string,
191 enum exception_event_kind ex_event,
192 struct symtab_and_line *sal);
7a292a7a 193
d85310f7
MS
194static void catch_exception_command_1 (enum exception_event_kind ex_event,
195 char *arg, int tempflag, int from_tty);
7a292a7a 196
a14ed312 197static void tcatch_command (char *arg, int from_tty);
7a292a7a 198
a14ed312 199static void ep_skip_leading_whitespace (char **s);
7a292a7a 200
c906108c
SS
201/* Prototypes for exported functions. */
202
c906108c
SS
203/* If FALSE, gdb will not use hardware support for watchpoints, even
204 if such is available. */
205static int can_use_hw_watchpoints;
206
fa8d40ab
JJ
207/* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
208 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
209 for unrecognized breakpoint locations.
210 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
211static enum auto_boolean pending_break_support;
212
a14ed312 213void _initialize_breakpoint (void);
c906108c 214
c5aa993b 215extern int addressprint; /* Print machine addresses? */
c906108c 216
c906108c
SS
217/* Are we executing breakpoint commands? */
218static int executing_breakpoint_commands;
219
c02f5703
MS
220/* Are overlay event breakpoints enabled? */
221static int overlay_events_enabled;
222
c906108c
SS
223/* Walk the following statement or block through all breakpoints.
224 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
225 breakpoint. */
226
5c44784c 227#define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next)
c906108c 228
5c44784c
JM
229#define ALL_BREAKPOINTS_SAFE(B,TMP) \
230 for (B = breakpoint_chain; \
231 B ? (TMP=B->next, 1): 0; \
232 B = TMP)
c906108c 233
7cc221ef
DJ
234/* Similar iterators for the low-level breakpoints. */
235
236#define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next)
237
238#define ALL_BP_LOCATIONS_SAFE(B,TMP) \
239 for (B = bp_location_chain; \
240 B ? (TMP=B->next, 1): 0; \
241 B = TMP)
242
c906108c
SS
243/* True if breakpoint hit counts should be displayed in breakpoint info. */
244
245int show_breakpoint_hit_counts = 1;
246
7cc221ef 247/* Chains of all breakpoints defined. */
c906108c
SS
248
249struct breakpoint *breakpoint_chain;
250
7cc221ef
DJ
251struct bp_location *bp_location_chain;
252
c906108c
SS
253/* Number of last breakpoint made. */
254
255int breakpoint_count;
256
c5aa993b
JM
257/* Pointer to current exception event record */
258static struct exception_event_record *current_exception_event;
c906108c 259
f83f82bc
AC
260/* Indicator of whether exception catchpoints should be nuked between
261 runs of a program. */
262int deprecated_exception_catchpoints_are_fragile = 0;
c5aa993b 263
c906108c 264/* Indicator of when exception catchpoints set-up should be
f83f82bc
AC
265 reinitialized -- e.g. when program is re-run. */
266int deprecated_exception_support_initialized = 0;
c906108c
SS
267
268/* This function returns a pointer to the string representation of the
269 pathname of the dynamically-linked library that has just been
270 loaded.
271
272 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
273 or undefined results are guaranteed.
274
275 This string's contents are only valid immediately after the
276 inferior has stopped in the dynamic linker hook, and becomes
277 invalid as soon as the inferior is continued. Clients should make
278 a copy of this string if they wish to continue the inferior and
279 then access the string. */
280
281#ifndef SOLIB_LOADED_LIBRARY_PATHNAME
282#define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
283#endif
284
285/* This function returns a pointer to the string representation of the
286 pathname of the dynamically-linked library that has just been
287 unloaded.
288
289 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
290 TRUE, or undefined results are guaranteed.
291
292 This string's contents are only valid immediately after the
293 inferior has stopped in the dynamic linker hook, and becomes
294 invalid as soon as the inferior is continued. Clients should make
295 a copy of this string if they wish to continue the inferior and
296 then access the string. */
297
298#ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
299#define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
300#endif
301
302/* This function is called by the "catch load" command. It allows the
303 debugger to be notified by the dynamic linker when a specified
304 library file (or any library file, if filename is NULL) is loaded. */
305
306#ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
307#define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
308 error ("catch of library loads not yet implemented on this platform")
309#endif
310
311/* This function is called by the "catch unload" command. It allows
312 the debugger to be notified by the dynamic linker when a specified
313 library file (or any library file, if filename is NULL) is
314 unloaded. */
315
316#ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
1272ad14 317#define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid, tempflag, filename, cond_string) \
c906108c
SS
318 error ("catch of library unloads not yet implemented on this platform")
319#endif
320
468d015d
JJ
321/* Return whether a breakpoint is an active enabled breakpoint. */
322static int
323breakpoint_enabled (struct breakpoint *b)
324{
0101ce28 325 return (b->enable_state == bp_enabled && !b->pending);
468d015d
JJ
326}
327
c906108c
SS
328/* Set breakpoint count to NUM. */
329
330void
fba45db2 331set_breakpoint_count (int num)
c906108c
SS
332{
333 breakpoint_count = num;
334 set_internalvar (lookup_internalvar ("bpnum"),
335 value_from_longest (builtin_type_int, (LONGEST) num));
336}
337
338/* Used in run_command to zero the hit count when a new run starts. */
339
340void
fba45db2 341clear_breakpoint_hit_counts (void)
c906108c
SS
342{
343 struct breakpoint *b;
344
345 ALL_BREAKPOINTS (b)
346 b->hit_count = 0;
347}
348
349/* Default address, symtab and line to put a breakpoint at
350 for "break" command with no arg.
351 if default_breakpoint_valid is zero, the other three are
352 not valid, and "break" with no arg is an error.
353
354 This set by print_stack_frame, which calls set_default_breakpoint. */
355
356int default_breakpoint_valid;
357CORE_ADDR default_breakpoint_address;
358struct symtab *default_breakpoint_symtab;
359int default_breakpoint_line;
360\f
361/* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
362 Advance *PP after the string and any trailing whitespace.
363
364 Currently the string can either be a number or "$" followed by the name
365 of a convenience variable. Making it an expression wouldn't work well
5c44784c
JM
366 for map_breakpoint_numbers (e.g. "4 + 5 + 6").
367
368 TRAILER is a character which can be found after the number; most
369 commonly this is `-'. If you don't want a trailer, use \0. */
c906108c 370static int
fba45db2 371get_number_trailer (char **pp, int trailer)
c906108c 372{
5c44784c 373 int retval = 0; /* default */
c906108c
SS
374 char *p = *pp;
375
376 if (p == NULL)
377 /* Empty line means refer to the last breakpoint. */
378 return breakpoint_count;
379 else if (*p == '$')
380 {
381 /* Make a copy of the name, so we can null-terminate it
c5aa993b 382 to pass to lookup_internalvar(). */
c906108c
SS
383 char *varname;
384 char *start = ++p;
278cd55f 385 struct value *val;
c906108c
SS
386
387 while (isalnum (*p) || *p == '_')
388 p++;
389 varname = (char *) alloca (p - start + 1);
390 strncpy (varname, start, p - start);
391 varname[p - start] = '\0';
392 val = value_of_internalvar (lookup_internalvar (varname));
df407dfe 393 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
5c44784c
JM
394 retval = (int) value_as_long (val);
395 else
396 {
397 printf_filtered ("Convenience variable must have integer value.\n");
398 retval = 0;
399 }
c906108c
SS
400 }
401 else
402 {
403 if (*p == '-')
404 ++p;
405 while (*p >= '0' && *p <= '9')
406 ++p;
407 if (p == *pp)
408 /* There is no number here. (e.g. "cond a == b"). */
5c44784c
JM
409 {
410 /* Skip non-numeric token */
411 while (*p && !isspace((int) *p))
412 ++p;
413 /* Return zero, which caller must interpret as error. */
414 retval = 0;
415 }
416 else
417 retval = atoi (*pp);
418 }
419 if (!(isspace (*p) || *p == '\0' || *p == trailer))
420 {
421 /* Trailing junk: return 0 and let caller print error msg. */
422 while (!(isspace (*p) || *p == '\0' || *p == trailer))
423 ++p;
424 retval = 0;
c906108c 425 }
c906108c
SS
426 while (isspace (*p))
427 p++;
428 *pp = p;
429 return retval;
430}
5c44784c 431
11cf8741 432
5c44784c
JM
433/* Like get_number_trailer, but don't allow a trailer. */
434int
fba45db2 435get_number (char **pp)
5c44784c
JM
436{
437 return get_number_trailer (pp, '\0');
438}
439
440/* Parse a number or a range.
441 * A number will be of the form handled by get_number.
442 * A range will be of the form <number1> - <number2>, and
443 * will represent all the integers between number1 and number2,
444 * inclusive.
445 *
446 * While processing a range, this fuction is called iteratively;
447 * At each call it will return the next value in the range.
448 *
449 * At the beginning of parsing a range, the char pointer PP will
450 * be advanced past <number1> and left pointing at the '-' token.
451 * Subsequent calls will not advance the pointer until the range
452 * is completed. The call that completes the range will advance
453 * pointer PP past <number2>.
454 */
455
456int
fba45db2 457get_number_or_range (char **pp)
5c44784c
JM
458{
459 static int last_retval, end_value;
460 static char *end_ptr;
461 static int in_range = 0;
462
463 if (**pp != '-')
464 {
465 /* Default case: pp is pointing either to a solo number,
466 or to the first number of a range. */
467 last_retval = get_number_trailer (pp, '-');
468 if (**pp == '-')
469 {
470 char **temp;
471
472 /* This is the start of a range (<number1> - <number2>).
473 Skip the '-', parse and remember the second number,
474 and also remember the end of the final token. */
475
476 temp = &end_ptr;
477 end_ptr = *pp + 1;
478 while (isspace ((int) *end_ptr))
479 end_ptr++; /* skip white space */
480 end_value = get_number (temp);
481 if (end_value < last_retval)
482 {
483 error ("inverted range");
484 }
485 else if (end_value == last_retval)
486 {
487 /* degenerate range (number1 == number2). Advance the
488 token pointer so that the range will be treated as a
489 single number. */
490 *pp = end_ptr;
491 }
492 else
493 in_range = 1;
494 }
495 }
496 else if (! in_range)
497 error ("negative value");
498 else
499 {
500 /* pp points to the '-' that betokens a range. All
501 number-parsing has already been done. Return the next
502 integer value (one greater than the saved previous value).
503 Do not advance the token pointer 'pp' until the end of range
504 is reached. */
505
506 if (++last_retval == end_value)
507 {
508 /* End of range reached; advance token pointer. */
509 *pp = end_ptr;
510 in_range = 0;
511 }
512 }
513 return last_retval;
514}
515
516
c906108c
SS
517\f
518/* condition N EXP -- set break condition of breakpoint N to EXP. */
519
520static void
fba45db2 521condition_command (char *arg, int from_tty)
c906108c 522{
52f0bd74 523 struct breakpoint *b;
c906108c 524 char *p;
52f0bd74 525 int bnum;
c906108c
SS
526
527 if (arg == 0)
528 error_no_arg ("breakpoint number");
529
530 p = arg;
531 bnum = get_number (&p);
5c44784c
JM
532 if (bnum == 0)
533 error ("Bad breakpoint argument: '%s'", arg);
c906108c
SS
534
535 ALL_BREAKPOINTS (b)
536 if (b->number == bnum)
c5aa993b
JM
537 {
538 if (b->cond)
539 {
b8c9b27d 540 xfree (b->cond);
c5aa993b
JM
541 b->cond = 0;
542 }
543 if (b->cond_string != NULL)
b8c9b27d 544 xfree (b->cond_string);
c906108c 545
c5aa993b
JM
546 if (*p == 0)
547 {
548 b->cond = 0;
549 b->cond_string = NULL;
550 if (from_tty)
551 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
552 }
553 else
554 {
555 arg = p;
556 /* I don't know if it matters whether this is the string the user
557 typed in or the decompiled expression. */
558 b->cond_string = savestring (arg, strlen (arg));
0101ce28
JJ
559 if (!b->pending)
560 {
561 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
562 if (*arg)
563 error ("Junk at end of expression");
564 }
c5aa993b
JM
565 }
566 breakpoints_changed ();
221ea385 567 breakpoint_modify_event (b->number);
c5aa993b
JM
568 return;
569 }
c906108c
SS
570
571 error ("No breakpoint number %d.", bnum);
572}
573
c906108c 574static void
fba45db2 575commands_command (char *arg, int from_tty)
c906108c 576{
52f0bd74 577 struct breakpoint *b;
c906108c 578 char *p;
52f0bd74 579 int bnum;
c906108c
SS
580 struct command_line *l;
581
582 /* If we allowed this, we would have problems with when to
583 free the storage, if we change the commands currently
584 being read from. */
585
586 if (executing_breakpoint_commands)
587 error ("Can't use the \"commands\" command among a breakpoint's commands.");
588
589 p = arg;
590 bnum = get_number (&p);
5c44784c 591
c906108c
SS
592 if (p && *p)
593 error ("Unexpected extra arguments following breakpoint number.");
c5aa993b 594
c906108c
SS
595 ALL_BREAKPOINTS (b)
596 if (b->number == bnum)
9ebf4acf
AC
597 {
598 char *tmpbuf = xstrprintf ("Type commands for when breakpoint %d is hit, one per line.",
599 bnum);
600 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
601 l = read_command_lines (tmpbuf, from_tty);
602 do_cleanups (cleanups);
603 free_command_lines (&b->commands);
604 b->commands = l;
605 breakpoints_changed ();
606 breakpoint_modify_event (b->number);
607 return;
c5aa993b 608 }
c906108c
SS
609 error ("No breakpoint number %d.", bnum);
610}
611\f
612/* Like target_read_memory() but if breakpoints are inserted, return
613 the shadow contents instead of the breakpoints themselves.
614
615 Read "memory data" from whatever target or inferior we have.
616 Returns zero if successful, errno value if not. EIO is used
617 for address out of bounds. If breakpoints are inserted, returns
618 shadow contents, not the breakpoints themselves. From breakpoint.c. */
619
620int
1f602b35 621deprecated_read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len)
c906108c
SS
622{
623 int status;
ffce0d52 624 struct bp_location *b;
c906108c
SS
625 CORE_ADDR bp_addr = 0;
626 int bp_size = 0;
627
628 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
629 /* No breakpoints on this machine. */
630 return target_read_memory (memaddr, myaddr, len);
c5aa993b 631
ffce0d52 632 ALL_BP_LOCATIONS (b)
c5aa993b 633 {
ffce0d52
DJ
634 if (b->owner->type == bp_none)
635 warning ("reading through apparently deleted breakpoint #%d?",
636 b->owner->number);
637
638 if (b->loc_type != bp_loc_software_breakpoint)
c5aa993b 639 continue;
ffce0d52 640 if (!b->inserted)
c5aa993b
JM
641 continue;
642 /* Addresses and length of the part of the breakpoint that
643 we need to copy. */
644 /* XXXX The m68k, sh and h8300 have different local and remote
645 breakpoint values. BREAKPOINT_FROM_PC still manages to
646 correctly determine the breakpoints memory address and size
647 for these targets. */
ffce0d52 648 bp_addr = b->address;
c5aa993b
JM
649 bp_size = 0;
650 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
651 continue;
652 if (bp_size == 0)
653 /* bp isn't valid */
654 continue;
655 if (bp_addr + bp_size <= memaddr)
656 /* The breakpoint is entirely before the chunk of memory we
657 are reading. */
658 continue;
659 if (bp_addr >= memaddr + len)
660 /* The breakpoint is entirely after the chunk of memory we are
661 reading. */
662 continue;
663 /* Copy the breakpoint from the shadow contents, and recurse for
664 the things before and after. */
c906108c 665 {
c5aa993b
JM
666 /* Offset within shadow_contents. */
667 int bptoffset = 0;
c906108c 668
c5aa993b
JM
669 if (bp_addr < memaddr)
670 {
671 /* Only copy the second part of the breakpoint. */
672 bp_size -= memaddr - bp_addr;
673 bptoffset = memaddr - bp_addr;
674 bp_addr = memaddr;
675 }
676
677 if (bp_addr + bp_size > memaddr + len)
678 {
679 /* Only copy the first part of the breakpoint. */
680 bp_size -= (bp_addr + bp_size) - (memaddr + len);
681 }
682
683 memcpy (myaddr + bp_addr - memaddr,
ffce0d52 684 b->shadow_contents + bptoffset, bp_size);
c5aa993b
JM
685
686 if (bp_addr > memaddr)
687 {
688 /* Copy the section of memory before the breakpoint. */
1f602b35 689 status = deprecated_read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
c5aa993b
JM
690 if (status != 0)
691 return status;
692 }
693
694 if (bp_addr + bp_size < memaddr + len)
695 {
696 /* Copy the section of memory after the breakpoint. */
1f602b35 697 status = deprecated_read_memory_nobpt (bp_addr + bp_size,
d85310f7
MS
698 myaddr + bp_addr + bp_size - memaddr,
699 memaddr + len - (bp_addr + bp_size));
c5aa993b
JM
700 if (status != 0)
701 return status;
702 }
703 return 0;
c906108c 704 }
c5aa993b 705 }
c906108c
SS
706 /* Nothing overlaps. Just call read_memory_noerr. */
707 return target_read_memory (memaddr, myaddr, len);
708}
c906108c 709\f
c5aa993b 710
687595f9 711/* A wrapper function for inserting catchpoints. */
3f8091c1 712static int
687595f9
DJ
713insert_catchpoint (struct ui_out *uo, void *args)
714{
715 struct breakpoint *b = (struct breakpoint *) args;
716 int val = -1;
717
718 switch (b->type)
719 {
720 case bp_catch_fork:
721 val = target_insert_fork_catchpoint (PIDGET (inferior_ptid));
722 break;
723 case bp_catch_vfork:
724 val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
725 break;
726 case bp_catch_exec:
727 val = target_insert_exec_catchpoint (PIDGET (inferior_ptid));
728 break;
729 default:
1171114a 730 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
687595f9
DJ
731 break;
732 }
733
734 if (val < 0)
2a78bfb5 735 throw_reason (RETURN_ERROR);
687595f9
DJ
736
737 return 0;
738}
739
7270d8f2
OF
740/* Helper routine: free the value chain for a breakpoint (watchpoint). */
741
742static void free_valchain (struct bp_location *b)
743{
744 struct value *v;
745 struct value *n;
746
747 /* Free the saved value chain. We will construct a new one
748 the next time the watchpoint is inserted. */
749 for (v = b->owner->val_chain; v; v = n)
750 {
751 n = v->next;
752 value_free (v);
753 }
754 b->owner->val_chain = NULL;
755}
756
879bfdc2
DJ
757/* Insert a low-level "breakpoint" of some type. BPT is the breakpoint.
758 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS,
759 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems.
760
761 NOTE drow/2003-09-09: This routine could be broken down to an object-style
762 method for each breakpoint or catchpoint type. */
26bb91f3 763static int
879bfdc2 764insert_bp_location (struct bp_location *bpt,
26bb91f3
DJ
765 struct ui_file *tmp_error_stream,
766 int *disabled_breaks, int *process_warning,
767 int *hw_breakpoint_error)
879bfdc2
DJ
768{
769 int val = 0;
770
771 /* Permanent breakpoints cannot be inserted or removed. Disabled
772 breakpoints should not be inserted. */
468d015d 773 if (!breakpoint_enabled (bpt->owner))
879bfdc2
DJ
774 return 0;
775
776 if (bpt->inserted || bpt->duplicate)
777 return 0;
778
779 if (bpt->loc_type == bp_loc_software_breakpoint
780 || bpt->loc_type == bp_loc_hardware_breakpoint)
781 {
782 /* First check to see if we have to handle an overlay. */
783 if (overlay_debugging == ovly_off
784 || bpt->section == NULL
785 || !(section_is_overlay (bpt->section)))
786 {
787 /* No overlay handling: just set the breakpoint. */
788
789 if (bpt->loc_type == bp_loc_hardware_breakpoint)
790 val = target_insert_hw_breakpoint (bpt->address,
791 bpt->shadow_contents);
792 else
793 val = target_insert_breakpoint (bpt->address,
794 bpt->shadow_contents);
795 }
796 else
797 {
798 /* This breakpoint is in an overlay section.
799 Shall we set a breakpoint at the LMA? */
800 if (!overlay_events_enabled)
801 {
802 /* Yes -- overlay event support is not active,
803 so we must try to set a breakpoint at the LMA.
804 This will not work for a hardware breakpoint. */
805 if (bpt->loc_type == bp_loc_hardware_breakpoint)
806 warning ("hardware breakpoint %d not supported in overlay!\n",
807 bpt->owner->number);
808 else
809 {
810 CORE_ADDR addr = overlay_unmapped_address (bpt->address,
811 bpt->section);
812 /* Set a software (trap) breakpoint at the LMA. */
813 val = target_insert_breakpoint (addr, bpt->shadow_contents);
814 if (val != 0)
815 fprintf_unfiltered (tmp_error_stream,
816 "Overlay breakpoint %d failed: in ROM?",
817 bpt->owner->number);
818 }
819 }
820 /* Shall we set a breakpoint at the VMA? */
821 if (section_is_mapped (bpt->section))
822 {
823 /* Yes. This overlay section is mapped into memory. */
824 if (bpt->loc_type == bp_loc_hardware_breakpoint)
825 val = target_insert_hw_breakpoint (bpt->address,
826 bpt->shadow_contents);
827 else
828 val = target_insert_breakpoint (bpt->address,
829 bpt->shadow_contents);
830 }
831 else
832 {
833 /* No. This breakpoint will not be inserted.
834 No error, but do not mark the bp as 'inserted'. */
835 return 0;
836 }
837 }
838
839 if (val)
840 {
841 /* Can't set the breakpoint. */
842#if defined (DISABLE_UNSETTABLE_BREAK)
843 if (DISABLE_UNSETTABLE_BREAK (bpt->address))
844 {
845 /* See also: disable_breakpoints_in_shlibs. */
846 val = 0;
847 bpt->owner->enable_state = bp_shlib_disabled;
848 if (!*disabled_breaks)
849 {
850 fprintf_unfiltered (tmp_error_stream,
851 "Cannot insert breakpoint %d.\n",
852 bpt->owner->number);
853 fprintf_unfiltered (tmp_error_stream,
854 "Temporarily disabling shared library breakpoints:\n");
855 }
856 *disabled_breaks = 1;
857 fprintf_unfiltered (tmp_error_stream,
858 "breakpoint #%d\n", bpt->owner->number);
859 }
860 else
861#endif
862 {
863#ifdef ONE_PROCESS_WRITETEXT
864 *process_warning = 1;
865#endif
866 if (bpt->loc_type == bp_loc_hardware_breakpoint)
867 {
868 *hw_breakpoint_error = 1;
869 fprintf_unfiltered (tmp_error_stream,
870 "Cannot insert hardware breakpoint %d.\n",
871 bpt->owner->number);
872 }
873 else
874 {
875 fprintf_unfiltered (tmp_error_stream,
876 "Cannot insert breakpoint %d.\n",
877 bpt->owner->number);
878 fprintf_filtered (tmp_error_stream,
879 "Error accessing memory address ");
880 print_address_numeric (bpt->address, 1, tmp_error_stream);
881 fprintf_filtered (tmp_error_stream, ": %s.\n",
882 safe_strerror (val));
883 }
884
885 }
886 }
887 else
888 bpt->inserted = 1;
889
890 return val;
891 }
892
893 else if (bpt->loc_type == bp_loc_hardware_watchpoint
894 /* NOTE drow/2003-09-08: This state only exists for removing
895 watchpoints. It's not clear that it's necessary... */
896 && bpt->owner->disposition != disp_del_at_next_stop)
897 {
898 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints
899 based on the expression. Ideally this should happen at a higher level,
900 and there should be one bp_location for each computed address we
901 must watch. As soon as a many-to-one mapping is available I'll
902 convert this. */
903
7789d0fa 904 int within_current_scope;
879bfdc2
DJ
905 struct value *mark = value_mark ();
906 struct value *v;
7789d0fa 907 struct frame_id saved_frame_id;
879bfdc2 908
7789d0fa 909 /* Save the current frame's ID so we can restore it after
879bfdc2
DJ
910 evaluating the watchpoint expression on its own frame. */
911 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
912 took a frame parameter, so that we didn't have to change the
913 selected frame. */
7789d0fa 914 saved_frame_id = get_frame_id (deprecated_selected_frame);
879bfdc2
DJ
915
916 /* Determine if the watchpoint is within scope. */
917 if (bpt->owner->exp_valid_block == NULL)
918 within_current_scope = 1;
919 else
920 {
921 struct frame_info *fi;
922 fi = frame_find_by_id (bpt->owner->watchpoint_frame);
923 within_current_scope = (fi != NULL);
924 if (within_current_scope)
925 select_frame (fi);
926 }
927
928 if (within_current_scope)
929 {
7270d8f2
OF
930 free_valchain (bpt);
931
879bfdc2
DJ
932 /* Evaluate the expression and cut the chain of values
933 produced off from the value chain.
934
935 Make sure the value returned isn't lazy; we use
936 laziness to determine what memory GDB actually needed
937 in order to compute the value of the expression. */
938 v = evaluate_expression (bpt->owner->exp);
939 VALUE_CONTENTS (v);
940 value_release_to_mark (mark);
941
942 bpt->owner->val_chain = v;
943 bpt->inserted = 1;
944
945 /* Look at each value on the value chain. */
946 for (; v; v = v->next)
947 {
948 /* If it's a memory location, and GDB actually needed
949 its contents to evaluate the expression, then we
950 must watch it. */
951 if (VALUE_LVAL (v) == lval_memory
952 && ! VALUE_LAZY (v))
953 {
df407dfe 954 struct type *vtype = check_typedef (value_type (v));
879bfdc2
DJ
955
956 /* We only watch structs and arrays if user asked
957 for it explicitly, never if they just happen to
958 appear in the middle of some value chain. */
959 if (v == bpt->owner->val_chain
960 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
961 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
962 {
963 CORE_ADDR addr;
964 int len, type;
965
df407dfe
AC
966 addr = VALUE_ADDRESS (v) + value_offset (v);
967 len = TYPE_LENGTH (value_type (v));
879bfdc2
DJ
968 type = hw_write;
969 if (bpt->owner->type == bp_read_watchpoint)
970 type = hw_read;
971 else if (bpt->owner->type == bp_access_watchpoint)
972 type = hw_access;
973
974 val = target_insert_watchpoint (addr, len, type);
975 if (val == -1)
976 {
977 /* Don't exit the loop, try to insert
978 every value on the value chain. That's
979 because we will be removing all the
980 watches below, and removing a
981 watchpoint we didn't insert could have
982 adverse effects. */
983 bpt->inserted = 0;
984 }
985 val = 0;
986 }
987 }
988 }
989 /* Failure to insert a watchpoint on any memory value in the
990 value chain brings us here. */
991 if (!bpt->inserted)
992 {
0bde7532 993 remove_breakpoint (bpt, mark_uninserted);
879bfdc2
DJ
994 *hw_breakpoint_error = 1;
995 fprintf_unfiltered (tmp_error_stream,
996 "Could not insert hardware watchpoint %d.\n",
997 bpt->owner->number);
998 val = -1;
999 }
1000 }
1001 else
1002 {
1003 printf_filtered ("Hardware watchpoint %d deleted ", bpt->owner->number);
1004 printf_filtered ("because the program has left the block \n");
1005 printf_filtered ("in which its expression is valid.\n");
1006 if (bpt->owner->related_breakpoint)
1007 bpt->owner->related_breakpoint->disposition = disp_del_at_next_stop;
1008 bpt->owner->disposition = disp_del_at_next_stop;
1009 }
1010
7789d0fa
AC
1011 /* Restore the selected frame. */
1012 select_frame (frame_find_by_id (saved_frame_id));
879bfdc2
DJ
1013
1014 return val;
1015 }
1016
1017 else if (ep_is_exception_catchpoint (bpt->owner))
1018 {
1019 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a
1020 breakpoint. Once again, it would be better if this was represented
1021 as two bp_locations. */
1022
1023 /* If we get here, we must have a callback mechanism for exception
1024 events -- with g++ style embedded label support, we insert
1025 ordinary breakpoints and not catchpoints. */
1026 val = target_insert_breakpoint (bpt->address, bpt->shadow_contents);
1027 if (val)
1028 {
1029 /* Couldn't set breakpoint for some reason */
1030 fprintf_unfiltered (tmp_error_stream,
1031 "Cannot insert catchpoint %d; disabling it.\n",
1032 bpt->owner->number);
1033 fprintf_filtered (tmp_error_stream,
1034 "Error accessing memory address ");
1035 print_address_numeric (bpt->address, 1, tmp_error_stream);
1036 fprintf_filtered (tmp_error_stream, ": %s.\n",
1037 safe_strerror (val));
1038 bpt->owner->enable_state = bp_disabled;
1039 }
1040 else
1041 {
1042 /* Bp set, now make sure callbacks are enabled */
1043 /* Format possible error msg */
1044 char *message = xstrprintf ("Error inserting catchpoint %d:\n",
1045 bpt->owner->number);
1046 struct cleanup *cleanups = make_cleanup (xfree, message);
1047 int val;
1048 args_for_catchpoint_enable args;
1049 args.kind = bpt->owner->type == bp_catch_catch ?
1050 EX_EVENT_CATCH : EX_EVENT_THROW;
1051 args.enable_p = 1;
1052 val = catch_errors (cover_target_enable_exception_callback,
1053 &args, message, RETURN_MASK_ALL);
1054 do_cleanups (cleanups);
1055 if (val != 0 && val != -1)
1056 bpt->inserted = 1;
1057
1058 /* Check if something went wrong; val == 0 can be ignored */
1059 if (val == -1)
1060 {
1061 /* something went wrong */
1062 fprintf_unfiltered (tmp_error_stream,
1063 "Cannot insert catchpoint %d; disabling it.\n",
1064 bpt->owner->number);
1065 bpt->owner->enable_state = bp_disabled;
1066 }
1067 }
1068
1069 return val;
1070 }
1071
1072 else if (bpt->owner->type == bp_catch_fork
1073 || bpt->owner->type == bp_catch_vfork
1074 || bpt->owner->type == bp_catch_exec)
1075 {
1076 char *prefix = xstrprintf ("warning: inserting catchpoint %d: ",
1077 bpt->owner->number);
1078 struct cleanup *cleanups = make_cleanup (xfree, prefix);
1079 val = catch_exceptions (uiout, insert_catchpoint, bpt->owner, prefix,
1080 RETURN_MASK_ERROR);
1081 do_cleanups (cleanups);
1082 if (val < 0)
1083 bpt->owner->enable_state = bp_disabled;
1084 else
1085 bpt->inserted = 1;
1640b821
DJ
1086
1087 /* We've already printed an error message if there was a problem
1088 inserting this catchpoint, and we've disabled the catchpoint,
1089 so just return success. */
1090 return 0;
879bfdc2
DJ
1091 }
1092
1093 return 0;
1094}
1095
c906108c
SS
1096/* insert_breakpoints is used when starting or continuing the program.
1097 remove_breakpoints is used when the program stops.
1098 Both return zero if successful,
1099 or an `errno' value if could not write the inferior. */
1100
1101int
fba45db2 1102insert_breakpoints (void)
c906108c 1103{
879bfdc2 1104 struct bp_location *b, *temp;
53a5351d 1105 int return_val = 0; /* return success code. */
c906108c
SS
1106 int val = 0;
1107 int disabled_breaks = 0;
81d0cc19
GS
1108 int hw_breakpoint_error = 0;
1109 int process_warning = 0;
c906108c 1110
81d0cc19
GS
1111 struct ui_file *tmp_error_stream = mem_fileopen ();
1112 make_cleanup_ui_file_delete (tmp_error_stream);
1113
1114 /* Explicitly mark the warning -- this will only be printed if
1115 there was an error. */
1116 fprintf_unfiltered (tmp_error_stream, "Warning:\n");
c906108c 1117
879bfdc2
DJ
1118 ALL_BP_LOCATIONS_SAFE (b, temp)
1119 {
1120 /* Permanent breakpoints cannot be inserted or removed. Disabled
1121 breakpoints should not be inserted. */
468d015d 1122 if (!breakpoint_enabled (b->owner))
879bfdc2
DJ
1123 continue;
1124
1125 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when
1126 hardware watchpoints are split into multiple loc breakpoints. */
1127 if ((b->loc_type == bp_loc_hardware_watchpoint
1128 || b->owner->type == bp_watchpoint) && !b->owner->val)
1129 {
1130 struct value *val;
1131 val = evaluate_expression (b->owner->exp);
1132 release_value (val);
1133 if (VALUE_LAZY (val))
1134 value_fetch_lazy (val);
1135 b->owner->val = val;
1136 }
a881cf8e 1137
879bfdc2
DJ
1138 val = insert_bp_location (b, tmp_error_stream,
1139 &disabled_breaks, &process_warning,
1140 &hw_breakpoint_error);
1141 if (val)
1142 return_val = val;
1143 }
c906108c 1144
879bfdc2 1145 if (return_val)
81d0cc19
GS
1146 {
1147 /* If a hardware breakpoint or watchpoint was inserted, add a
1148 message about possibly exhausted resources. */
879bfdc2 1149 if (hw_breakpoint_error)
81d0cc19 1150 {
c6510018
MS
1151 fprintf_unfiltered (tmp_error_stream,
1152 "Could not insert hardware breakpoints:\n\
1153You may have requested too many hardware breakpoints/watchpoints.\n");
81d0cc19 1154 }
c6510018 1155#ifdef ONE_PROCESS_WRITETEXT
81d0cc19 1156 if (process_warning)
c6510018
MS
1157 fprintf_unfiltered (tmp_error_stream,
1158 "The same program may be running in another process.");
1159#endif
81d0cc19
GS
1160 target_terminal_ours_for_output ();
1161 error_stream (tmp_error_stream);
1162 }
53a5351d 1163 return return_val;
c906108c
SS
1164}
1165
c906108c 1166int
fba45db2 1167remove_breakpoints (void)
c906108c 1168{
0bde7532 1169 struct bp_location *b;
c906108c
SS
1170 int val;
1171
0bde7532 1172 ALL_BP_LOCATIONS (b)
c5aa993b 1173 {
0bde7532 1174 if (b->inserted)
c5aa993b
JM
1175 {
1176 val = remove_breakpoint (b, mark_uninserted);
1177 if (val != 0)
1178 return val;
1179 }
1180 }
c906108c
SS
1181 return 0;
1182}
1183
692590c1 1184int
80ce1ecb 1185remove_hw_watchpoints (void)
692590c1 1186{
0bde7532 1187 struct bp_location *b;
692590c1
MS
1188 int val;
1189
0bde7532 1190 ALL_BP_LOCATIONS (b)
692590c1 1191 {
0bde7532 1192 if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint)
692590c1
MS
1193 {
1194 val = remove_breakpoint (b, mark_uninserted);
1195 if (val != 0)
1196 return val;
1197 }
1198 }
1199 return 0;
1200}
1201
c906108c 1202int
fba45db2 1203reattach_breakpoints (int pid)
c906108c 1204{
0bde7532 1205 struct bp_location *b;
c906108c 1206 int val;
ce696e05 1207 struct cleanup *old_chain = save_inferior_ptid ();
c906108c 1208
ce696e05
KB
1209 /* Set inferior_ptid; remove_breakpoint uses this global. */
1210 inferior_ptid = pid_to_ptid (pid);
0bde7532 1211 ALL_BP_LOCATIONS (b)
c5aa993b 1212 {
0bde7532 1213 if (b->inserted)
c5aa993b
JM
1214 {
1215 remove_breakpoint (b, mark_inserted);
0bde7532
DJ
1216 if (b->loc_type == bp_loc_hardware_breakpoint)
1217 val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
c5aa993b 1218 else
0bde7532
DJ
1219 val = target_insert_breakpoint (b->address, b->shadow_contents);
1220 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of
1221 breakpoints. It's wrong for watchpoints, for example. */
c5aa993b
JM
1222 if (val != 0)
1223 {
ce696e05 1224 do_cleanups (old_chain);
c5aa993b
JM
1225 return val;
1226 }
1227 }
1228 }
ce696e05 1229 do_cleanups (old_chain);
c906108c
SS
1230 return 0;
1231}
1232
1233void
fba45db2 1234update_breakpoints_after_exec (void)
c906108c 1235{
c5aa993b
JM
1236 struct breakpoint *b;
1237 struct breakpoint *temp;
c906108c
SS
1238
1239 /* Doing this first prevents the badness of having delete_breakpoint()
1240 write a breakpoint's current "shadow contents" to lift the bp. That
1241 shadow is NOT valid after an exec()! */
1242 mark_breakpoints_out ();
1243
1244 ALL_BREAKPOINTS_SAFE (b, temp)
c5aa993b
JM
1245 {
1246 /* Solib breakpoints must be explicitly reset after an exec(). */
1247 if (b->type == bp_shlib_event)
1248 {
1249 delete_breakpoint (b);
1250 continue;
1251 }
c906108c 1252
1900040c
MS
1253 /* Thread event breakpoints must be set anew after an exec(),
1254 as must overlay event breakpoints. */
1255 if (b->type == bp_thread_event || b->type == bp_overlay_event)
c4093a6a
JM
1256 {
1257 delete_breakpoint (b);
1258 continue;
1259 }
1260
c5aa993b
JM
1261 /* Step-resume breakpoints are meaningless after an exec(). */
1262 if (b->type == bp_step_resume)
1263 {
1264 delete_breakpoint (b);
1265 continue;
1266 }
1267
1268 /* Ditto the sigtramp handler breakpoints. */
1269 if (b->type == bp_through_sigtramp)
1270 {
1271 delete_breakpoint (b);
1272 continue;
1273 }
1274
1275 /* Ditto the exception-handling catchpoints. */
1276 if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw))
1277 {
1278 delete_breakpoint (b);
1279 continue;
1280 }
1281
1282 /* Don't delete an exec catchpoint, because else the inferior
1283 won't stop when it ought!
1284
1285 Similarly, we probably ought to keep vfork catchpoints, 'cause
53a5351d
JM
1286 on this target, we may not be able to stop when the vfork is
1287 seen, but only when the subsequent exec is seen. (And because
1288 deleting fork catchpoints here but not vfork catchpoints will
1289 seem mysterious to users, keep those too.)
c5aa993b
JM
1290
1291 ??rehrauer: Let's hope that merely clearing out this catchpoint's
1292 target address field, if any, is sufficient to have it be reset
644a1fe1
JB
1293 automagically. Certainly on HP-UX that's true.
1294
1295 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
41989fcd
AC
1296 valid code address on some platforms (like the mn10300
1297 simulators). We shouldn't assign any special interpretation to
1298 a breakpoint with a zero address. And in fact, GDB doesn't ---
1299 I can't see what that comment above is talking about. As far
1300 as I can tell, setting the address of a
644a1fe1
JB
1301 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
1302 is meaningless, since those are implemented with HP-UX kernel
1303 hackery, not by storing breakpoint instructions somewhere. */
c5aa993b
JM
1304 if ((b->type == bp_catch_exec) ||
1305 (b->type == bp_catch_vfork) ||
1306 (b->type == bp_catch_fork))
1307 {
5cab636d 1308 b->loc->address = (CORE_ADDR) NULL;
c5aa993b
JM
1309 continue;
1310 }
1311
1312 /* bp_finish is a special case. The only way we ought to be able
1313 to see one of these when an exec() has happened, is if the user
1314 caught a vfork, and then said "finish". Ordinarily a finish just
1315 carries them to the call-site of the current callee, by setting
1316 a temporary bp there and resuming. But in this case, the finish
1317 will carry them entirely through the vfork & exec.
1318
1319 We don't want to allow a bp_finish to remain inserted now. But
1320 we can't safely delete it, 'cause finish_command has a handle to
1321 the bp on a bpstat, and will later want to delete it. There's a
1322 chance (and I've seen it happen) that if we delete the bp_finish
1323 here, that its storage will get reused by the time finish_command
1324 gets 'round to deleting the "use to be a bp_finish" breakpoint.
1325 We really must allow finish_command to delete a bp_finish.
1326
53a5351d
JM
1327 In the absense of a general solution for the "how do we know
1328 it's safe to delete something others may have handles to?"
1329 problem, what we'll do here is just uninsert the bp_finish, and
1330 let finish_command delete it.
1331
1332 (We know the bp_finish is "doomed" in the sense that it's
1333 momentary, and will be deleted as soon as finish_command sees
1334 the inferior stopped. So it doesn't matter that the bp's
1335 address is probably bogus in the new a.out, unlike e.g., the
1336 solib breakpoints.) */
c5aa993b 1337
c5aa993b
JM
1338 if (b->type == bp_finish)
1339 {
1340 continue;
1341 }
1342
1343 /* Without a symbolic address, we have little hope of the
1344 pre-exec() address meaning the same thing in the post-exec()
1345 a.out. */
1346 if (b->addr_string == NULL)
1347 {
1348 delete_breakpoint (b);
1349 continue;
1350 }
1351
1352 /* If this breakpoint has survived the above battery of checks, then
1353 it must have a symbolic address. Be sure that it gets reevaluated
644a1fe1
JB
1354 to a target address, rather than reusing the old evaluation.
1355
1356 Jim Blandy <jimb@redhat.com>: As explained above in the comment
1357 for bp_catch_exec and friends, I'm pretty sure this is entirely
1358 unnecessary. A call to breakpoint_re_set_one always recomputes
1359 the breakpoint's address from scratch, or deletes it if it can't.
1360 So I think this assignment could be deleted without effect. */
5cab636d 1361 b->loc->address = (CORE_ADDR) NULL;
c5aa993b 1362 }
1900040c
MS
1363 /* FIXME what about longjmp breakpoints? Re-create them here? */
1364 create_overlay_event_breakpoint ("_ovly_debug_event");
c906108c
SS
1365}
1366
1367int
fba45db2 1368detach_breakpoints (int pid)
c906108c 1369{
0bde7532 1370 struct bp_location *b;
c906108c 1371 int val;
ce696e05 1372 struct cleanup *old_chain = save_inferior_ptid ();
c5aa993b 1373
39f77062
KB
1374 if (pid == PIDGET (inferior_ptid))
1375 error ("Cannot detach breakpoints of inferior_ptid");
c5aa993b 1376
ce696e05
KB
1377 /* Set inferior_ptid; remove_breakpoint uses this global. */
1378 inferior_ptid = pid_to_ptid (pid);
0bde7532 1379 ALL_BP_LOCATIONS (b)
c5aa993b 1380 {
0bde7532 1381 if (b->inserted)
c5aa993b
JM
1382 {
1383 val = remove_breakpoint (b, mark_inserted);
1384 if (val != 0)
1385 {
ce696e05 1386 do_cleanups (old_chain);
c5aa993b
JM
1387 return val;
1388 }
1389 }
1390 }
ce696e05 1391 do_cleanups (old_chain);
c906108c
SS
1392 return 0;
1393}
1394
1395static int
0bde7532 1396remove_breakpoint (struct bp_location *b, insertion_state_t is)
c906108c
SS
1397{
1398 int val;
c5aa993b 1399
0bde7532 1400 if (b->owner->enable_state == bp_permanent)
c2c6d25f
JM
1401 /* Permanent breakpoints cannot be inserted or removed. */
1402 return 0;
1403
0bde7532 1404 if (b->owner->type == bp_none)
53a5351d 1405 warning ("attempted to remove apparently deleted breakpoint #%d?",
0bde7532
DJ
1406 b->owner->number);
1407
1408 if (b->loc_type == bp_loc_software_breakpoint
1409 || b->loc_type == bp_loc_hardware_breakpoint)
c906108c 1410 {
c02f5703
MS
1411 /* "Normal" instruction breakpoint: either the standard
1412 trap-instruction bp (bp_breakpoint), or a
1413 bp_hardware_breakpoint. */
1414
1415 /* First check to see if we have to handle an overlay. */
1416 if (overlay_debugging == ovly_off
0bde7532
DJ
1417 || b->section == NULL
1418 || !(section_is_overlay (b->section)))
c02f5703
MS
1419 {
1420 /* No overlay handling: just remove the breakpoint. */
1421
0bde7532
DJ
1422 if (b->loc_type == bp_loc_hardware_breakpoint)
1423 val = target_remove_hw_breakpoint (b->address,
1424 b->shadow_contents);
c02f5703 1425 else
0bde7532 1426 val = target_remove_breakpoint (b->address, b->shadow_contents);
c02f5703 1427 }
c906108c
SS
1428 else
1429 {
c02f5703
MS
1430 /* This breakpoint is in an overlay section.
1431 Did we set a breakpoint at the LMA? */
1432 if (!overlay_events_enabled)
1433 {
1434 /* Yes -- overlay event support is not active, so we
1435 should have set a breakpoint at the LMA. Remove it.
1436 */
0bde7532
DJ
1437 CORE_ADDR addr = overlay_unmapped_address (b->address,
1438 b->section);
c02f5703
MS
1439 /* Ignore any failures: if the LMA is in ROM, we will
1440 have already warned when we failed to insert it. */
0bde7532
DJ
1441 if (b->loc_type == bp_loc_hardware_breakpoint)
1442 target_remove_hw_breakpoint (addr, b->shadow_contents);
c02f5703 1443 else
0bde7532 1444 target_remove_breakpoint (addr, b->shadow_contents);
c02f5703
MS
1445 }
1446 /* Did we set a breakpoint at the VMA?
1447 If so, we will have marked the breakpoint 'inserted'. */
0bde7532 1448 if (b->inserted)
c906108c 1449 {
c02f5703
MS
1450 /* Yes -- remove it. Previously we did not bother to
1451 remove the breakpoint if the section had been
1452 unmapped, but let's not rely on that being safe. We
1453 don't know what the overlay manager might do. */
0bde7532
DJ
1454 if (b->loc_type == bp_loc_hardware_breakpoint)
1455 val = target_remove_hw_breakpoint (b->address,
1456 b->shadow_contents);
c02f5703 1457 else
0bde7532
DJ
1458 val = target_remove_breakpoint (b->address,
1459 b->shadow_contents);
c906108c 1460 }
c02f5703
MS
1461 else
1462 {
1463 /* No -- not inserted, so no need to remove. No error. */
1464 val = 0;
1465 }
c906108c
SS
1466 }
1467 if (val)
1468 return val;
0bde7532 1469 b->inserted = (is == mark_inserted);
c906108c 1470 }
0bde7532 1471 else if (b->loc_type == bp_loc_hardware_watchpoint
468d015d 1472 && breakpoint_enabled (b->owner)
0bde7532 1473 && !b->duplicate)
c906108c 1474 {
278cd55f
AC
1475 struct value *v;
1476 struct value *n;
c5aa993b 1477
0bde7532 1478 b->inserted = (is == mark_inserted);
c906108c 1479 /* Walk down the saved value chain. */
0bde7532 1480 for (v = b->owner->val_chain; v; v = v->next)
c906108c
SS
1481 {
1482 /* For each memory reference remove the watchpoint
1483 at that address. */
5c44784c
JM
1484 if (VALUE_LVAL (v) == lval_memory
1485 && ! VALUE_LAZY (v))
c906108c 1486 {
df407dfe 1487 struct type *vtype = check_typedef (value_type (v));
2e70b7b9 1488
0bde7532 1489 if (v == b->owner->val_chain
2e70b7b9
MS
1490 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
1491 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
1492 {
1493 CORE_ADDR addr;
1494 int len, type;
1495
df407dfe
AC
1496 addr = VALUE_ADDRESS (v) + value_offset (v);
1497 len = TYPE_LENGTH (value_type (v));
2e70b7b9 1498 type = hw_write;
0bde7532 1499 if (b->owner->type == bp_read_watchpoint)
2e70b7b9 1500 type = hw_read;
0bde7532 1501 else if (b->owner->type == bp_access_watchpoint)
2e70b7b9
MS
1502 type = hw_access;
1503
1504 val = target_remove_watchpoint (addr, len, type);
1505 if (val == -1)
0bde7532 1506 b->inserted = 1;
2e70b7b9
MS
1507 val = 0;
1508 }
c906108c
SS
1509 }
1510 }
1511 /* Failure to remove any of the hardware watchpoints comes here. */
0bde7532 1512 if ((is == mark_uninserted) && (b->inserted))
53a5351d 1513 warning ("Could not remove hardware watchpoint %d.",
0bde7532 1514 b->owner->number);
c906108c 1515 }
0bde7532
DJ
1516 else if ((b->owner->type == bp_catch_fork ||
1517 b->owner->type == bp_catch_vfork ||
1518 b->owner->type == bp_catch_exec)
468d015d 1519 && breakpoint_enabled (b->owner)
0bde7532 1520 && !b->duplicate)
c906108c
SS
1521 {
1522 val = -1;
0bde7532 1523 switch (b->owner->type)
c5aa993b
JM
1524 {
1525 case bp_catch_fork:
39f77062 1526 val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
c5aa993b
JM
1527 break;
1528 case bp_catch_vfork:
39f77062 1529 val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
c5aa993b
JM
1530 break;
1531 case bp_catch_exec:
39f77062 1532 val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
c5aa993b 1533 break;
ac9a91a7 1534 default:
53a5351d 1535 warning ("Internal error, %s line %d.", __FILE__, __LINE__);
ac9a91a7 1536 break;
c5aa993b 1537 }
c906108c
SS
1538 if (val)
1539 return val;
0bde7532 1540 b->inserted = (is == mark_inserted);
c906108c 1541 }
0bde7532
DJ
1542 else if ((b->owner->type == bp_catch_catch ||
1543 b->owner->type == bp_catch_throw)
468d015d 1544 && breakpoint_enabled (b->owner)
0bde7532 1545 && !b->duplicate)
c906108c
SS
1546 {
1547
0bde7532 1548 val = target_remove_breakpoint (b->address, b->shadow_contents);
c906108c 1549 if (val)
c5aa993b 1550 return val;
0bde7532 1551 b->inserted = (is == mark_inserted);
c906108c 1552 }
0bde7532
DJ
1553 else if (ep_is_exception_catchpoint (b->owner)
1554 && b->inserted /* sometimes previous insert doesn't happen */
468d015d 1555 && breakpoint_enabled (b->owner)
0bde7532 1556 && !b->duplicate)
c906108c
SS
1557 {
1558
0bde7532 1559 val = target_remove_breakpoint (b->address, b->shadow_contents);
c906108c 1560 if (val)
c5aa993b
JM
1561 return val;
1562
0bde7532 1563 b->inserted = (is == mark_inserted);
c906108c
SS
1564 }
1565
1566 return 0;
1567}
1568
1569/* Clear the "inserted" flag in all breakpoints. */
1570
1571void
fba45db2 1572mark_breakpoints_out (void)
c906108c 1573{
075f6582 1574 struct bp_location *bpt;
c906108c 1575
075f6582
DJ
1576 ALL_BP_LOCATIONS (bpt)
1577 bpt->inserted = 0;
c906108c
SS
1578}
1579
53a5351d
JM
1580/* Clear the "inserted" flag in all breakpoints and delete any
1581 breakpoints which should go away between runs of the program.
c906108c
SS
1582
1583 Plus other such housekeeping that has to be done for breakpoints
1584 between runs.
1585
53a5351d
JM
1586 Note: this function gets called at the end of a run (by
1587 generic_mourn_inferior) and when a run begins (by
1588 init_wait_for_inferior). */
c906108c
SS
1589
1590
1591
1592void
fba45db2 1593breakpoint_init_inferior (enum inf_context context)
c906108c 1594{
52f0bd74 1595 struct breakpoint *b, *temp;
075f6582 1596 struct bp_location *bpt;
c906108c
SS
1597 static int warning_needed = 0;
1598
075f6582
DJ
1599 ALL_BP_LOCATIONS (bpt)
1600 bpt->inserted = 0;
1601
c906108c 1602 ALL_BREAKPOINTS_SAFE (b, temp)
c5aa993b 1603 {
c5aa993b
JM
1604 switch (b->type)
1605 {
1606 case bp_call_dummy:
1607 case bp_watchpoint_scope:
c906108c 1608
c5aa993b
JM
1609 /* If the call dummy breakpoint is at the entry point it will
1610 cause problems when the inferior is rerun, so we better
1611 get rid of it.
c906108c 1612
c5aa993b
JM
1613 Also get rid of scope breakpoints. */
1614 delete_breakpoint (b);
1615 break;
c906108c 1616
c5aa993b
JM
1617 case bp_watchpoint:
1618 case bp_hardware_watchpoint:
1619 case bp_read_watchpoint:
1620 case bp_access_watchpoint:
c906108c 1621
c5aa993b
JM
1622 /* Likewise for watchpoints on local expressions. */
1623 if (b->exp_valid_block != NULL)
1624 delete_breakpoint (b);
c860120c
PM
1625 if (context == inf_starting)
1626 {
1627 /* Reset val field to force reread of starting value
1628 in insert_breakpoints. */
1629 if (b->val)
1630 value_free (b->val);
1631 b->val = NULL;
1632 }
c5aa993b
JM
1633 break;
1634 default:
1635 /* Likewise for exception catchpoints in dynamic-linked
1636 executables where required */
f83f82bc
AC
1637 if (ep_is_exception_catchpoint (b)
1638 && deprecated_exception_catchpoints_are_fragile)
c5aa993b
JM
1639 {
1640 warning_needed = 1;
c906108c 1641 delete_breakpoint (b);
c5aa993b
JM
1642 }
1643 break;
1644 }
1645 }
c906108c 1646
f83f82bc
AC
1647 if (deprecated_exception_catchpoints_are_fragile)
1648 deprecated_exception_support_initialized = 0;
c906108c 1649
c5aa993b 1650 /* Don't issue the warning unless it's really needed... */
c906108c
SS
1651 if (warning_needed && (context != inf_exited))
1652 {
53a5351d
JM
1653 warning ("Exception catchpoints from last run were deleted.");
1654 warning ("You must reinsert them explicitly.");
c906108c 1655 warning_needed = 0;
c5aa993b 1656 }
c906108c
SS
1657}
1658
c2c6d25f
JM
1659/* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
1660 exists at PC. It returns ordinary_breakpoint_here if it's an
1661 ordinary breakpoint, or permanent_breakpoint_here if it's a
1662 permanent breakpoint.
1663 - When continuing from a location with an ordinary breakpoint, we
1664 actually single step once before calling insert_breakpoints.
1665 - When continuing from a localion with a permanent breakpoint, we
1666 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
1667 the target, to advance the PC past the breakpoint. */
c906108c 1668
c2c6d25f 1669enum breakpoint_here
fba45db2 1670breakpoint_here_p (CORE_ADDR pc)
c906108c 1671{
075f6582 1672 struct bp_location *bpt;
c2c6d25f 1673 int any_breakpoint_here = 0;
c906108c 1674
075f6582
DJ
1675 ALL_BP_LOCATIONS (bpt)
1676 {
1677 if (bpt->loc_type != bp_loc_software_breakpoint
1678 && bpt->loc_type != bp_loc_hardware_breakpoint)
1679 continue;
1680
468d015d 1681 if ((breakpoint_enabled (bpt->owner)
075f6582
DJ
1682 || bpt->owner->enable_state == bp_permanent)
1683 && bpt->address == pc) /* bp is enabled and matches pc */
1684 {
1685 if (overlay_debugging
1686 && section_is_overlay (bpt->section)
1687 && !section_is_mapped (bpt->section))
1688 continue; /* unmapped overlay -- can't be a match */
1689 else if (bpt->owner->enable_state == bp_permanent)
1690 return permanent_breakpoint_here;
1691 else
1692 any_breakpoint_here = 1;
1693 }
1694 }
c906108c 1695
c2c6d25f 1696 return any_breakpoint_here ? ordinary_breakpoint_here : 0;
c906108c
SS
1697}
1698
c2c6d25f 1699
53a5351d
JM
1700/* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
1701 but it only returns true if there is actually a breakpoint inserted
1702 at PC. */
c906108c
SS
1703
1704int
fba45db2 1705breakpoint_inserted_here_p (CORE_ADDR pc)
c906108c 1706{
075f6582 1707 struct bp_location *bpt;
c906108c 1708
075f6582 1709 ALL_BP_LOCATIONS (bpt)
c5aa993b 1710 {
075f6582
DJ
1711 if (bpt->loc_type != bp_loc_software_breakpoint
1712 && bpt->loc_type != bp_loc_hardware_breakpoint)
1713 continue;
1714
1715 if (bpt->inserted
1716 && bpt->address == pc) /* bp is inserted and matches pc */
1717 {
1718 if (overlay_debugging
1719 && section_is_overlay (bpt->section)
1720 && !section_is_mapped (bpt->section))
1721 continue; /* unmapped overlay -- can't be a match */
1722 else
1723 return 1;
1724 }
c5aa993b 1725 }
c906108c
SS
1726
1727 return 0;
1728}
1729
4fa8626c
DJ
1730/* This function returns non-zero iff there is a software breakpoint
1731 inserted at PC. */
1732
1733int
1734software_breakpoint_inserted_here_p (CORE_ADDR pc)
1735{
1736 struct bp_location *bpt;
1737 int any_breakpoint_here = 0;
1738
1739 ALL_BP_LOCATIONS (bpt)
1740 {
1741 if (bpt->loc_type != bp_loc_software_breakpoint)
1742 continue;
1743
1744 if ((breakpoint_enabled (bpt->owner)
1745 || bpt->owner->enable_state == bp_permanent)
1746 && bpt->inserted
1747 && bpt->address == pc) /* bp is enabled and matches pc */
1748 {
1749 if (overlay_debugging
1750 && section_is_overlay (bpt->section)
1751 && !section_is_mapped (bpt->section))
1752 continue; /* unmapped overlay -- can't be a match */
1753 else
1754 return 1;
1755 }
1756 }
1757
1758 return 0;
1759}
1760
075f6582
DJ
1761/* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
1762 PC is valid for process/thread PTID. */
c906108c
SS
1763
1764int
39f77062 1765breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid)
c906108c 1766{
075f6582 1767 struct bp_location *bpt;
c906108c
SS
1768 int thread;
1769
39f77062 1770 thread = pid_to_thread_id (ptid);
c906108c 1771
075f6582 1772 ALL_BP_LOCATIONS (bpt)
c5aa993b 1773 {
075f6582
DJ
1774 if (bpt->loc_type != bp_loc_software_breakpoint
1775 && bpt->loc_type != bp_loc_hardware_breakpoint)
1776 continue;
1777
468d015d 1778 if ((breakpoint_enabled (bpt->owner)
075f6582
DJ
1779 || bpt->owner->enable_state == bp_permanent)
1780 && bpt->address == pc
1781 && (bpt->owner->thread == -1 || bpt->owner->thread == thread))
1782 {
1783 if (overlay_debugging
1784 && section_is_overlay (bpt->section)
1785 && !section_is_mapped (bpt->section))
1786 continue; /* unmapped overlay -- can't be a match */
1787 else
1788 return 1;
1789 }
c5aa993b 1790 }
c906108c
SS
1791
1792 return 0;
1793}
c906108c 1794\f
c5aa993b 1795
c906108c
SS
1796/* bpstat stuff. External routines' interfaces are documented
1797 in breakpoint.h. */
1798
1799int
fba45db2 1800ep_is_catchpoint (struct breakpoint *ep)
c906108c
SS
1801{
1802 return
1803 (ep->type == bp_catch_load)
1804 || (ep->type == bp_catch_unload)
1805 || (ep->type == bp_catch_fork)
1806 || (ep->type == bp_catch_vfork)
1807 || (ep->type == bp_catch_exec)
1808 || (ep->type == bp_catch_catch)
d85310f7 1809 || (ep->type == bp_catch_throw);
c906108c 1810
c5aa993b 1811 /* ??rehrauer: Add more kinds here, as are implemented... */
c906108c 1812}
c5aa993b 1813
c906108c 1814int
fba45db2 1815ep_is_shlib_catchpoint (struct breakpoint *ep)
c906108c
SS
1816{
1817 return
1818 (ep->type == bp_catch_load)
d85310f7 1819 || (ep->type == bp_catch_unload);
c906108c
SS
1820}
1821
1822int
fba45db2 1823ep_is_exception_catchpoint (struct breakpoint *ep)
c906108c
SS
1824{
1825 return
1826 (ep->type == bp_catch_catch)
d85310f7 1827 || (ep->type == bp_catch_throw);
c906108c
SS
1828}
1829
1830/* Clear a bpstat so that it says we are not at any breakpoint.
1831 Also free any storage that is part of a bpstat. */
1832
1833void
fba45db2 1834bpstat_clear (bpstat *bsp)
c906108c
SS
1835{
1836 bpstat p;
1837 bpstat q;
1838
1839 if (bsp == 0)
1840 return;
1841 p = *bsp;
1842 while (p != NULL)
1843 {
1844 q = p->next;
1845 if (p->old_val != NULL)
1846 value_free (p->old_val);
c2b8ed2c 1847 free_command_lines (&p->commands);
b8c9b27d 1848 xfree (p);
c906108c
SS
1849 p = q;
1850 }
1851 *bsp = NULL;
1852}
1853
1854/* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1855 is part of the bpstat is copied as well. */
1856
1857bpstat
fba45db2 1858bpstat_copy (bpstat bs)
c906108c
SS
1859{
1860 bpstat p = NULL;
1861 bpstat tmp;
1862 bpstat retval = NULL;
1863
1864 if (bs == NULL)
1865 return bs;
1866
1867 for (; bs != NULL; bs = bs->next)
1868 {
1869 tmp = (bpstat) xmalloc (sizeof (*tmp));
1870 memcpy (tmp, bs, sizeof (*tmp));
31cc81e9
DJ
1871 if (bs->commands != NULL)
1872 tmp->commands = copy_command_lines (bs->commands);
1873 if (bs->old_val != NULL)
1874 tmp->old_val = value_copy (bs->old_val);
1875
c906108c
SS
1876 if (p == NULL)
1877 /* This is the first thing in the chain. */
1878 retval = tmp;
1879 else
1880 p->next = tmp;
1881 p = tmp;
1882 }
1883 p->next = NULL;
1884 return retval;
1885}
1886
1887/* Find the bpstat associated with this breakpoint */
1888
1889bpstat
fba45db2 1890bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
c906108c 1891{
c5aa993b
JM
1892 if (bsp == NULL)
1893 return NULL;
c906108c 1894
c5aa993b
JM
1895 for (; bsp != NULL; bsp = bsp->next)
1896 {
1897 if (bsp->breakpoint_at == breakpoint)
1898 return bsp;
1899 }
c906108c
SS
1900 return NULL;
1901}
1902
1903/* Find a step_resume breakpoint associated with this bpstat.
1904 (If there are multiple step_resume bp's on the list, this function
1905 will arbitrarily pick one.)
1906
1907 It is an error to use this function if BPSTAT doesn't contain a
1908 step_resume breakpoint.
1909
1910 See wait_for_inferior's use of this function. */
1911struct breakpoint *
fba45db2 1912bpstat_find_step_resume_breakpoint (bpstat bsp)
c906108c 1913{
8601f500
MS
1914 int current_thread;
1915
c906108c
SS
1916 if (bsp == NULL)
1917 error ("Internal error (bpstat_find_step_resume_breakpoint)");
1918
8601f500
MS
1919 current_thread = pid_to_thread_id (inferior_ptid);
1920
c906108c
SS
1921 for (; bsp != NULL; bsp = bsp->next)
1922 {
1923 if ((bsp->breakpoint_at != NULL) &&
8601f500
MS
1924 (bsp->breakpoint_at->type == bp_step_resume) &&
1925 (bsp->breakpoint_at->thread == current_thread ||
1926 bsp->breakpoint_at->thread == -1))
c5aa993b 1927 return bsp->breakpoint_at;
c906108c
SS
1928 }
1929
1930 error ("Internal error (no step_resume breakpoint found)");
1931}
1932
1933
1934/* Return the breakpoint number of the first breakpoint we are stopped
1935 at. *BSP upon return is a bpstat which points to the remaining
1936 breakpoints stopped at (but which is not guaranteed to be good for
1937 anything but further calls to bpstat_num).
1938 Return 0 if passed a bpstat which does not indicate any breakpoints. */
1939
1940int
fba45db2 1941bpstat_num (bpstat *bsp)
c906108c
SS
1942{
1943 struct breakpoint *b;
1944
1945 if ((*bsp) == NULL)
1946 return 0; /* No more breakpoint values */
1947 else
1948 {
1949 b = (*bsp)->breakpoint_at;
1950 *bsp = (*bsp)->next;
1951 if (b == NULL)
1952 return -1; /* breakpoint that's been deleted since */
1953 else
c5aa993b 1954 return b->number; /* We have its number */
c906108c
SS
1955 }
1956}
1957
1958/* Modify BS so that the actions will not be performed. */
1959
1960void
fba45db2 1961bpstat_clear_actions (bpstat bs)
c906108c
SS
1962{
1963 for (; bs != NULL; bs = bs->next)
1964 {
c2b8ed2c 1965 free_command_lines (&bs->commands);
c906108c
SS
1966 if (bs->old_val != NULL)
1967 {
1968 value_free (bs->old_val);
1969 bs->old_val = NULL;
1970 }
1971 }
1972}
1973
1974/* Stub for cleaning up our state if we error-out of a breakpoint command */
c906108c 1975static void
4efb68b1 1976cleanup_executing_breakpoints (void *ignore)
c906108c
SS
1977{
1978 executing_breakpoint_commands = 0;
1979}
1980
1981/* Execute all the commands associated with all the breakpoints at this
1982 location. Any of these commands could cause the process to proceed
1983 beyond this point, etc. We look out for such changes by checking
1984 the global "breakpoint_proceeded" after each command. */
1985
1986void
fba45db2 1987bpstat_do_actions (bpstat *bsp)
c906108c
SS
1988{
1989 bpstat bs;
1990 struct cleanup *old_chain;
c906108c
SS
1991
1992 /* Avoid endless recursion if a `source' command is contained
1993 in bs->commands. */
1994 if (executing_breakpoint_commands)
1995 return;
1996
1997 executing_breakpoint_commands = 1;
1998 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
1999
2000top:
2001 /* Note that (as of this writing), our callers all appear to
2002 be passing us the address of global stop_bpstat. And, if
2003 our calls to execute_control_command cause the inferior to
2004 proceed, that global (and hence, *bsp) will change.
2005
2006 We must be careful to not touch *bsp unless the inferior
2007 has not proceeded. */
2008
2009 /* This pointer will iterate over the list of bpstat's. */
2010 bs = *bsp;
2011
2012 breakpoint_proceeded = 0;
2013 for (; bs != NULL; bs = bs->next)
2014 {
6c50ab1c
JB
2015 struct command_line *cmd;
2016 struct cleanup *this_cmd_tree_chain;
2017
2018 /* Take ownership of the BSP's command tree, if it has one.
2019
2020 The command tree could legitimately contain commands like
2021 'step' and 'next', which call clear_proceed_status, which
2022 frees stop_bpstat's command tree. To make sure this doesn't
2023 free the tree we're executing out from under us, we need to
2024 take ownership of the tree ourselves. Since a given bpstat's
2025 commands are only executed once, we don't need to copy it; we
2026 can clear the pointer in the bpstat, and make sure we free
2027 the tree when we're done. */
c906108c 2028 cmd = bs->commands;
6c50ab1c
JB
2029 bs->commands = 0;
2030 this_cmd_tree_chain = make_cleanup_free_command_lines (&cmd);
2031
c906108c
SS
2032 while (cmd != NULL)
2033 {
2034 execute_control_command (cmd);
2035
2036 if (breakpoint_proceeded)
2037 break;
2038 else
2039 cmd = cmd->next;
2040 }
6c50ab1c
JB
2041
2042 /* We can free this command tree now. */
2043 do_cleanups (this_cmd_tree_chain);
2044
c906108c
SS
2045 if (breakpoint_proceeded)
2046 /* The inferior is proceeded by the command; bomb out now.
2047 The bpstat chain has been blown away by wait_for_inferior.
2048 But since execution has stopped again, there is a new bpstat
2049 to look at, so start over. */
2050 goto top;
c906108c 2051 }
c2b8ed2c 2052 do_cleanups (old_chain);
c906108c
SS
2053}
2054
e514a9d6 2055/* This is the normal print function for a bpstat. In the future,
c906108c 2056 much of this logic could (should?) be moved to bpstat_stop_status,
e514a9d6
JM
2057 by having it set different print_it values.
2058
2059 Current scheme: When we stop, bpstat_print() is called. It loops
2060 through the bpstat list of things causing this stop, calling the
2061 print_bp_stop_message function on each one. The behavior of the
2062 print_bp_stop_message function depends on the print_it field of
2063 bpstat. If such field so indicates, call this function here.
2064
2065 Return values from this routine (ultimately used by bpstat_print()
2066 and normal_stop() to decide what to do):
2067 PRINT_NOTHING: Means we already printed all we needed to print,
2068 don't print anything else.
2069 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
2070 that something to be followed by a location.
2071 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
2072 that something to be followed by a location.
2073 PRINT_UNKNOWN: Means we printed nothing or we need to do some more
2074 analysis. */
c906108c 2075
917317f4 2076static enum print_stop_action
fba45db2 2077print_it_typical (bpstat bs)
c906108c 2078{
3b31d625 2079 struct cleanup *old_chain, *ui_out_chain;
8b93c638
JM
2080 struct ui_stream *stb;
2081 stb = ui_out_stream_new (uiout);
b02eeafb 2082 old_chain = make_cleanup_ui_out_stream_delete (stb);
c906108c
SS
2083 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
2084 which has since been deleted. */
e514a9d6 2085 if (bs->breakpoint_at == NULL)
917317f4 2086 return PRINT_UNKNOWN;
c906108c 2087
e514a9d6 2088 switch (bs->breakpoint_at->type)
c906108c 2089 {
e514a9d6
JM
2090 case bp_breakpoint:
2091 case bp_hardware_breakpoint:
5cab636d
DJ
2092 if (bs->breakpoint_at->loc->address != bs->breakpoint_at->loc->requested_address)
2093 breakpoint_adjustment_warning (bs->breakpoint_at->loc->requested_address,
2094 bs->breakpoint_at->loc->address,
76897487 2095 bs->breakpoint_at->number, 1);
8b93c638
JM
2096 annotate_breakpoint (bs->breakpoint_at->number);
2097 ui_out_text (uiout, "\nBreakpoint ");
9dc5e2a9 2098 if (ui_out_is_mi_like_p (uiout))
fb40c209 2099 ui_out_field_string (uiout, "reason", "breakpoint-hit");
8b93c638
JM
2100 ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number);
2101 ui_out_text (uiout, ", ");
2102 return PRINT_SRC_AND_LOC;
e514a9d6
JM
2103 break;
2104
2105 case bp_shlib_event:
917317f4
JM
2106 /* Did we stop because the user set the stop_on_solib_events
2107 variable? (If so, we report this as a generic, "Stopped due
2108 to shlib event" message.) */
e514a9d6
JM
2109 printf_filtered ("Stopped due to shared library event\n");
2110 return PRINT_NOTHING;
2111 break;
2112
c4093a6a
JM
2113 case bp_thread_event:
2114 /* Not sure how we will get here.
2115 GDB should not stop for these breakpoints. */
2116 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
2117 return PRINT_NOTHING;
2118 break;
2119
1900040c
MS
2120 case bp_overlay_event:
2121 /* By analogy with the thread event, GDB should not stop for these. */
2122 printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
2123 return PRINT_NOTHING;
2124 break;
2125
e514a9d6 2126 case bp_catch_load:
c906108c
SS
2127 annotate_catchpoint (bs->breakpoint_at->number);
2128 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
e514a9d6
JM
2129 printf_filtered ("loaded");
2130 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
2131 return PRINT_SRC_AND_LOC;
2132 break;
2133
2134 case bp_catch_unload:
2135 annotate_catchpoint (bs->breakpoint_at->number);
2136 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2137 printf_filtered ("unloaded");
2138 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
2139 return PRINT_SRC_AND_LOC;
2140 break;
2141
2142 case bp_catch_fork:
2143 annotate_catchpoint (bs->breakpoint_at->number);
2144 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2145 printf_filtered ("forked");
53a5351d
JM
2146 printf_filtered (" process %d), ",
2147 bs->breakpoint_at->forked_inferior_pid);
917317f4 2148 return PRINT_SRC_AND_LOC;
e514a9d6
JM
2149 break;
2150
2151 case bp_catch_vfork:
2152 annotate_catchpoint (bs->breakpoint_at->number);
2153 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
2154 printf_filtered ("vforked");
2155 printf_filtered (" process %d), ",
2156 bs->breakpoint_at->forked_inferior_pid);
2157 return PRINT_SRC_AND_LOC;
2158 break;
2159
2160 case bp_catch_exec:
c906108c
SS
2161 annotate_catchpoint (bs->breakpoint_at->number);
2162 printf_filtered ("\nCatchpoint %d (exec'd %s), ",
c5aa993b
JM
2163 bs->breakpoint_at->number,
2164 bs->breakpoint_at->exec_pathname);
917317f4 2165 return PRINT_SRC_AND_LOC;
e514a9d6
JM
2166 break;
2167
2168 case bp_catch_catch:
53a5351d
JM
2169 if (current_exception_event &&
2170 (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
c5aa993b
JM
2171 {
2172 annotate_catchpoint (bs->breakpoint_at->number);
53a5351d
JM
2173 printf_filtered ("\nCatchpoint %d (exception caught), ",
2174 bs->breakpoint_at->number);
c5aa993b
JM
2175 printf_filtered ("throw location ");
2176 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2177 printf_filtered ("%s:%d",
2178 CURRENT_EXCEPTION_THROW_FILE,
2179 CURRENT_EXCEPTION_THROW_LINE);
2180 else
2181 printf_filtered ("unknown");
2182
2183 printf_filtered (", catch location ");
2184 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2185 printf_filtered ("%s:%d",
2186 CURRENT_EXCEPTION_CATCH_FILE,
2187 CURRENT_EXCEPTION_CATCH_LINE);
2188 else
2189 printf_filtered ("unknown");
2190
2191 printf_filtered ("\n");
e514a9d6
JM
2192 /* don't bother to print location frame info */
2193 return PRINT_SRC_ONLY;
c5aa993b 2194 }
c906108c 2195 else
c5aa993b 2196 {
e514a9d6
JM
2197 /* really throw, some other bpstat will handle it */
2198 return PRINT_UNKNOWN;
c5aa993b 2199 }
e514a9d6
JM
2200 break;
2201
2202 case bp_catch_throw:
53a5351d
JM
2203 if (current_exception_event &&
2204 (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
c5aa993b
JM
2205 {
2206 annotate_catchpoint (bs->breakpoint_at->number);
53a5351d
JM
2207 printf_filtered ("\nCatchpoint %d (exception thrown), ",
2208 bs->breakpoint_at->number);
c5aa993b
JM
2209 printf_filtered ("throw location ");
2210 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
2211 printf_filtered ("%s:%d",
2212 CURRENT_EXCEPTION_THROW_FILE,
2213 CURRENT_EXCEPTION_THROW_LINE);
2214 else
2215 printf_filtered ("unknown");
2216
2217 printf_filtered (", catch location ");
2218 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
2219 printf_filtered ("%s:%d",
2220 CURRENT_EXCEPTION_CATCH_FILE,
2221 CURRENT_EXCEPTION_CATCH_LINE);
2222 else
2223 printf_filtered ("unknown");
2224
2225 printf_filtered ("\n");
e514a9d6
JM
2226 /* don't bother to print location frame info */
2227 return PRINT_SRC_ONLY;
c5aa993b 2228 }
c906108c 2229 else
c5aa993b 2230 {
e514a9d6
JM
2231 /* really catch, some other bpstat will handle it */
2232 return PRINT_UNKNOWN;
c5aa993b 2233 }
e514a9d6 2234 break;
c906108c 2235
e514a9d6
JM
2236 case bp_watchpoint:
2237 case bp_hardware_watchpoint:
2238 if (bs->old_val != NULL)
2239 {
2240 annotate_watchpoint (bs->breakpoint_at->number);
9dc5e2a9 2241 if (ui_out_is_mi_like_p (uiout))
fb40c209 2242 ui_out_field_string (uiout, "reason", "watchpoint-trigger");
8b93c638 2243 mention (bs->breakpoint_at);
3b31d625 2244 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
8b93c638
JM
2245 ui_out_text (uiout, "\nOld value = ");
2246 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2247 ui_out_field_stream (uiout, "old", stb);
2248 ui_out_text (uiout, "\nNew value = ");
2249 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2250 ui_out_field_stream (uiout, "new", stb);
3b31d625 2251 do_cleanups (ui_out_chain);
8b93c638 2252 ui_out_text (uiout, "\n");
e514a9d6
JM
2253 value_free (bs->old_val);
2254 bs->old_val = NULL;
2255 }
2256 /* More than one watchpoint may have been triggered. */
2257 return PRINT_UNKNOWN;
2258 break;
2259
2260 case bp_read_watchpoint:
9dc5e2a9 2261 if (ui_out_is_mi_like_p (uiout))
fb40c209 2262 ui_out_field_string (uiout, "reason", "read-watchpoint-trigger");
8b93c638 2263 mention (bs->breakpoint_at);
3b31d625 2264 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
8b93c638
JM
2265 ui_out_text (uiout, "\nValue = ");
2266 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
2267 ui_out_field_stream (uiout, "value", stb);
3b31d625 2268 do_cleanups (ui_out_chain);
8b93c638 2269 ui_out_text (uiout, "\n");
917317f4 2270 return PRINT_UNKNOWN;
e514a9d6
JM
2271 break;
2272
2273 case bp_access_watchpoint:
8b93c638
JM
2274 if (bs->old_val != NULL)
2275 {
2276 annotate_watchpoint (bs->breakpoint_at->number);
9dc5e2a9 2277 if (ui_out_is_mi_like_p (uiout))
fb40c209 2278 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
8b93c638 2279 mention (bs->breakpoint_at);
3b31d625 2280 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
8b93c638
JM
2281 ui_out_text (uiout, "\nOld value = ");
2282 value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
2283 ui_out_field_stream (uiout, "old", stb);
2284 value_free (bs->old_val);
2285 bs->old_val = NULL;
2286 ui_out_text (uiout, "\nNew value = ");
2287 }
2288 else
2289 {
2290 mention (bs->breakpoint_at);
9dc5e2a9 2291 if (ui_out_is_mi_like_p (uiout))
c97fe386 2292 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
3b31d625 2293 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value");
8b93c638
JM
2294 ui_out_text (uiout, "\nValue = ");
2295 }
2296 value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default);
2297 ui_out_field_stream (uiout, "new", stb);
3b31d625 2298 do_cleanups (ui_out_chain);
8b93c638 2299 ui_out_text (uiout, "\n");
917317f4 2300 return PRINT_UNKNOWN;
e514a9d6 2301 break;
4ce44c66 2302
e514a9d6
JM
2303 /* Fall through, we don't deal with these types of breakpoints
2304 here. */
2305
11cf8741 2306 case bp_finish:
9dc5e2a9 2307 if (ui_out_is_mi_like_p (uiout))
fb40c209 2308 ui_out_field_string (uiout, "reason", "function-finished");
8b93c638
JM
2309 return PRINT_UNKNOWN;
2310 break;
2311
e514a9d6 2312 case bp_until:
9dc5e2a9 2313 if (ui_out_is_mi_like_p (uiout))
fb40c209 2314 ui_out_field_string (uiout, "reason", "location-reached");
8b93c638
JM
2315 return PRINT_UNKNOWN;
2316 break;
2317
c2d11a7d 2318 case bp_none:
e514a9d6
JM
2319 case bp_longjmp:
2320 case bp_longjmp_resume:
2321 case bp_step_resume:
2322 case bp_through_sigtramp:
2323 case bp_watchpoint_scope:
2324 case bp_call_dummy:
2325 default:
2326 return PRINT_UNKNOWN;
2327 }
2328}
2329
2330/* Generic routine for printing messages indicating why we
2331 stopped. The behavior of this function depends on the value
2332 'print_it' in the bpstat structure. Under some circumstances we
2333 may decide not to print anything here and delegate the task to
2334 normal_stop(). */
2335
2336static enum print_stop_action
2337print_bp_stop_message (bpstat bs)
2338{
2339 switch (bs->print_it)
2340 {
2341 case print_it_noop:
2342 /* Nothing should be printed for this bpstat entry. */
2343 return PRINT_UNKNOWN;
2344 break;
2345
2346 case print_it_done:
2347 /* We still want to print the frame, but we already printed the
2348 relevant messages. */
2349 return PRINT_SRC_AND_LOC;
2350 break;
2351
2352 case print_it_normal:
3086aeae
DJ
2353 /* Normal case. Call the breakpoint's print_it method, or
2354 print_it_typical. */
2355 if (bs->breakpoint_at != NULL && bs->breakpoint_at->ops != NULL
2356 && bs->breakpoint_at->ops->print_it != NULL)
2357 return bs->breakpoint_at->ops->print_it (bs->breakpoint_at);
2358 else
2359 return print_it_typical (bs);
e514a9d6 2360 break;
3086aeae 2361
e514a9d6 2362 default:
8e65ff28
AC
2363 internal_error (__FILE__, __LINE__,
2364 "print_bp_stop_message: unrecognized enum value");
e514a9d6 2365 break;
c906108c 2366 }
c906108c
SS
2367}
2368
e514a9d6
JM
2369/* Print a message indicating what happened. This is called from
2370 normal_stop(). The input to this routine is the head of the bpstat
2371 list - a list of the eventpoints that caused this stop. This
2372 routine calls the generic print routine for printing a message
2373 about reasons for stopping. This will print (for example) the
2374 "Breakpoint n," part of the output. The return value of this
2375 routine is one of:
c906108c 2376
917317f4
JM
2377 PRINT_UNKNOWN: Means we printed nothing
2378 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
c5aa993b
JM
2379 code to print the location. An example is
2380 "Breakpoint 1, " which should be followed by
2381 the location.
917317f4 2382 PRINT_SRC_ONLY: Means we printed something, but there is no need
c5aa993b
JM
2383 to also print the location part of the message.
2384 An example is the catch/throw messages, which
917317f4
JM
2385 don't require a location appended to the end.
2386 PRINT_NOTHING: We have done some printing and we don't need any
2387 further info to be printed.*/
c906108c 2388
917317f4 2389enum print_stop_action
fba45db2 2390bpstat_print (bpstat bs)
c906108c
SS
2391{
2392 int val;
c5aa993b 2393
c906108c 2394 /* Maybe another breakpoint in the chain caused us to stop.
53a5351d
JM
2395 (Currently all watchpoints go on the bpstat whether hit or not.
2396 That probably could (should) be changed, provided care is taken
c906108c 2397 with respect to bpstat_explains_signal). */
e514a9d6
JM
2398 for (; bs; bs = bs->next)
2399 {
2400 val = print_bp_stop_message (bs);
2401 if (val == PRINT_SRC_ONLY
2402 || val == PRINT_SRC_AND_LOC
2403 || val == PRINT_NOTHING)
2404 return val;
2405 }
c906108c 2406
e514a9d6
JM
2407 /* We reached the end of the chain, or we got a null BS to start
2408 with and nothing was printed. */
917317f4 2409 return PRINT_UNKNOWN;
c906108c
SS
2410}
2411
2412/* Evaluate the expression EXP and return 1 if value is zero.
2413 This is used inside a catch_errors to evaluate the breakpoint condition.
2414 The argument is a "struct expression *" that has been cast to char * to
2415 make it pass through catch_errors. */
2416
2417static int
4efb68b1 2418breakpoint_cond_eval (void *exp)
c906108c 2419{
278cd55f 2420 struct value *mark = value_mark ();
c5aa993b 2421 int i = !value_true (evaluate_expression ((struct expression *) exp));
c906108c
SS
2422 value_free_to_mark (mark);
2423 return i;
2424}
2425
2426/* Allocate a new bpstat and chain it to the current one. */
2427
2428static bpstat
831662b3 2429bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ )
c906108c
SS
2430{
2431 bpstat bs;
2432
2433 bs = (bpstat) xmalloc (sizeof (*bs));
2434 cbs->next = bs;
2435 bs->breakpoint_at = b;
2436 /* If the condition is false, etc., don't do the commands. */
2437 bs->commands = NULL;
2438 bs->old_val = NULL;
2439 bs->print_it = print_it_normal;
2440 return bs;
2441}
2442\f
2443/* Possible return values for watchpoint_check (this can't be an enum
2444 because of check_errors). */
2445/* The watchpoint has been deleted. */
2446#define WP_DELETED 1
2447/* The value has changed. */
2448#define WP_VALUE_CHANGED 2
2449/* The value has not changed. */
2450#define WP_VALUE_NOT_CHANGED 3
2451
2452#define BP_TEMPFLAG 1
2453#define BP_HARDWAREFLAG 2
2454
2455/* Check watchpoint condition. */
2456
2457static int
4efb68b1 2458watchpoint_check (void *p)
c906108c
SS
2459{
2460 bpstat bs = (bpstat) p;
2461 struct breakpoint *b;
2462 struct frame_info *fr;
2463 int within_current_scope;
2464
2465 b = bs->breakpoint_at;
2466
2467 if (b->exp_valid_block == NULL)
2468 within_current_scope = 1;
2469 else
2470 {
2471 /* There is no current frame at this moment. If we're going to have
c5aa993b
JM
2472 any chance of handling watchpoints on local variables, we'll need
2473 the frame chain (so we can determine if we're in scope). */
2474 reinit_frame_cache ();
101dcfbe 2475 fr = frame_find_by_id (b->watchpoint_frame);
c906108c 2476 within_current_scope = (fr != NULL);
c12260ac
CV
2477 /* in_function_epilogue_p() returns a non-zero value if we're still
2478 in the function but the stack frame has already been invalidated.
2479 Since we can't rely on the values of local variables after the
2480 stack has been destroyed, we are treating the watchpoint in that
a957e642
CV
2481 state as `not changed' without further checking.
2482
2483 vinschen/2003-09-04: The former implementation left out the case
2484 that the watchpoint frame couldn't be found by frame_find_by_id()
2485 because the current PC is currently in an epilogue. Calling
2486 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */
a6fbcf2f 2487 if ((!within_current_scope || fr == get_current_frame ())
c12260ac
CV
2488 && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ()))
2489 return WP_VALUE_NOT_CHANGED;
a6fbcf2f 2490 if (fr && within_current_scope)
c906108c
SS
2491 /* If we end up stopping, the current frame will get selected
2492 in normal_stop. So this call to select_frame won't affect
2493 the user. */
0f7d239c 2494 select_frame (fr);
c906108c 2495 }
c5aa993b 2496
c906108c
SS
2497 if (within_current_scope)
2498 {
2499 /* We use value_{,free_to_}mark because it could be a
2500 *long* time before we return to the command level and
c5aa993b
JM
2501 call free_all_values. We can't call free_all_values because
2502 we might be in the middle of evaluating a function call. */
c906108c 2503
278cd55f
AC
2504 struct value *mark = value_mark ();
2505 struct value *new_val = evaluate_expression (bs->breakpoint_at->exp);
c906108c
SS
2506 if (!value_equal (b->val, new_val))
2507 {
2508 release_value (new_val);
2509 value_free_to_mark (mark);
2510 bs->old_val = b->val;
2511 b->val = new_val;
2512 /* We will stop here */
2513 return WP_VALUE_CHANGED;
2514 }
2515 else
2516 {
2517 /* Nothing changed, don't do anything. */
2518 value_free_to_mark (mark);
2519 /* We won't stop here */
2520 return WP_VALUE_NOT_CHANGED;
2521 }
2522 }
2523 else
2524 {
2525 /* This seems like the only logical thing to do because
c5aa993b
JM
2526 if we temporarily ignored the watchpoint, then when
2527 we reenter the block in which it is valid it contains
2528 garbage (in the case of a function, it may have two
2529 garbage values, one before and one after the prologue).
2530 So we can't even detect the first assignment to it and
2531 watch after that (since the garbage may or may not equal
2532 the first value assigned). */
4ce44c66
JM
2533 /* We print all the stop information in print_it_typical(), but
2534 in this case, by the time we call print_it_typical() this bp
2535 will be deleted already. So we have no choice but print the
2536 information here. */
9dc5e2a9 2537 if (ui_out_is_mi_like_p (uiout))
fb40c209 2538 ui_out_field_string (uiout, "reason", "watchpoint-scope");
8b93c638
JM
2539 ui_out_text (uiout, "\nWatchpoint ");
2540 ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number);
2541 ui_out_text (uiout, " deleted because the program has left the block in\n\
2542which its expression is valid.\n");
4ce44c66 2543
c906108c 2544 if (b->related_breakpoint)
b5de0fa7
EZ
2545 b->related_breakpoint->disposition = disp_del_at_next_stop;
2546 b->disposition = disp_del_at_next_stop;
c906108c
SS
2547
2548 return WP_DELETED;
2549 }
2550}
2551
9709f61c 2552/* Get a bpstat associated with having just stopped at address
46587c42
JJ
2553 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the
2554 target thinks we stopped due to a hardware watchpoint, 0 if we
2555 know we did not trigger a hardware watchpoint, and -1 if we do not know. */
c906108c
SS
2556
2557/* Determine whether we stopped at a breakpoint, etc, or whether we
2558 don't understand this stop. Result is a chain of bpstat's such that:
2559
c5aa993b 2560 if we don't understand the stop, the result is a null pointer.
c906108c 2561
c5aa993b 2562 if we understand why we stopped, the result is not null.
c906108c 2563
c5aa993b
JM
2564 Each element of the chain refers to a particular breakpoint or
2565 watchpoint at which we have stopped. (We may have stopped for
2566 several reasons concurrently.)
c906108c 2567
c5aa993b
JM
2568 Each element of the chain has valid next, breakpoint_at,
2569 commands, FIXME??? fields. */
c906108c
SS
2570
2571bpstat
00d4360e 2572bpstat_stop_status (CORE_ADDR bp_addr, ptid_t ptid, int stopped_by_watchpoint)
c906108c 2573{
52f0bd74 2574 struct breakpoint *b, *temp;
c906108c
SS
2575 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
2576 int real_breakpoint = 0;
2577 /* Root of the chain of bpstat's */
2578 struct bpstats root_bs[1];
2579 /* Pointer to the last thing in the chain currently. */
2580 bpstat bs = root_bs;
fa5281d0 2581 int thread_id = pid_to_thread_id (ptid);
c906108c 2582
c906108c 2583 ALL_BREAKPOINTS_SAFE (b, temp)
c5aa993b 2584 {
468d015d 2585 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent)
c5aa993b
JM
2586 continue;
2587
2588 if (b->type != bp_watchpoint
46587c42
JJ
2589 && b->type != bp_hardware_watchpoint
2590 && b->type != bp_read_watchpoint
2591 && b->type != bp_access_watchpoint
c5aa993b
JM
2592 && b->type != bp_hardware_breakpoint
2593 && b->type != bp_catch_fork
2594 && b->type != bp_catch_vfork
2595 && b->type != bp_catch_exec
2596 && b->type != bp_catch_catch
2597 && b->type != bp_catch_throw) /* a non-watchpoint bp */
9f04af04 2598 {
5cab636d 2599 if (b->loc->address != bp_addr) /* address doesn't match */
9f04af04
MS
2600 continue;
2601 if (overlay_debugging /* unmapped overlay section */
cf3a9e5b
DJ
2602 && section_is_overlay (b->loc->section)
2603 && !section_is_mapped (b->loc->section))
9f04af04
MS
2604 continue;
2605 }
c906108c 2606
46587c42
JJ
2607 /* Continuable hardware watchpoints are treated as non-existent if the
2608 reason we stopped wasn't a hardware watchpoint (we didn't stop on
2609 some data address). Otherwise gdb won't stop on a break instruction
2610 in the code (not from a breakpoint) when a hardware watchpoint has
2611 been defined. */
2612
2613 if ((b->type == bp_hardware_watchpoint
2614 || b->type == bp_read_watchpoint
2615 || b->type == bp_access_watchpoint)
2616 && !stopped_by_watchpoint)
2617 continue;
2618
c02f5703
MS
2619 if (b->type == bp_hardware_breakpoint)
2620 {
9709f61c 2621 if (b->loc->address != bp_addr)
c02f5703
MS
2622 continue;
2623 if (overlay_debugging /* unmapped overlay section */
cf3a9e5b
DJ
2624 && section_is_overlay (b->loc->section)
2625 && !section_is_mapped (b->loc->section))
c02f5703
MS
2626 continue;
2627 }
c5aa993b 2628
c5aa993b
JM
2629 /* Is this a catchpoint of a load or unload? If so, did we
2630 get a load or unload of the specified library? If not,
2631 ignore it. */
2632 if ((b->type == bp_catch_load)
c906108c 2633#if defined(SOLIB_HAVE_LOAD_EVENT)
39f77062 2634 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid))
c5aa993b 2635 || ((b->dll_pathname != NULL)
53a5351d 2636 && (strcmp (b->dll_pathname,
39f77062
KB
2637 SOLIB_LOADED_LIBRARY_PATHNAME (
2638 PIDGET (inferior_ptid)))
53a5351d 2639 != 0)))
c906108c 2640#endif
c5aa993b
JM
2641 )
2642 continue;
2643
2644 if ((b->type == bp_catch_unload)
c906108c 2645#if defined(SOLIB_HAVE_UNLOAD_EVENT)
39f77062 2646 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid))
c5aa993b 2647 || ((b->dll_pathname != NULL)
53a5351d 2648 && (strcmp (b->dll_pathname,
39f77062
KB
2649 SOLIB_UNLOADED_LIBRARY_PATHNAME (
2650 PIDGET (inferior_ptid)))
53a5351d 2651 != 0)))
c906108c 2652#endif
c5aa993b
JM
2653 )
2654 continue;
c906108c 2655
c5aa993b 2656 if ((b->type == bp_catch_fork)
47932f85
DJ
2657 && !inferior_has_forked (PIDGET (inferior_ptid),
2658 &b->forked_inferior_pid))
c5aa993b 2659 continue;
c906108c 2660
c5aa993b 2661 if ((b->type == bp_catch_vfork)
47932f85
DJ
2662 && !inferior_has_vforked (PIDGET (inferior_ptid),
2663 &b->forked_inferior_pid))
c5aa993b 2664 continue;
c906108c 2665
c5aa993b 2666 if ((b->type == bp_catch_exec)
47932f85 2667 && !inferior_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
c5aa993b 2668 continue;
c906108c 2669
c5aa993b
JM
2670 if (ep_is_exception_catchpoint (b) &&
2671 !(current_exception_event = target_get_current_exception_event ()))
2672 continue;
c906108c 2673
c5aa993b
JM
2674 /* Come here if it's a watchpoint, or if the break address matches */
2675
2676 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
2677
2678 /* Watchpoints may change this, if not found to have triggered. */
2679 bs->stop = 1;
2680 bs->print = 1;
2681
53a5351d
JM
2682 if (b->type == bp_watchpoint ||
2683 b->type == bp_hardware_watchpoint)
c5aa993b 2684 {
9ebf4acf
AC
2685 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2686 b->number);
2687 struct cleanup *cleanups = make_cleanup (xfree, message);
2688 int e = catch_errors (watchpoint_check, bs, message,
2689 RETURN_MASK_ALL);
2690 do_cleanups (cleanups);
2691 switch (e)
c5aa993b
JM
2692 {
2693 case WP_DELETED:
2694 /* We've already printed what needs to be printed. */
4ce44c66
JM
2695 /* Actually this is superfluous, because by the time we
2696 call print_it_typical() the wp will be already deleted,
2697 and the function will return immediately. */
c5aa993b
JM
2698 bs->print_it = print_it_done;
2699 /* Stop. */
2700 break;
2701 case WP_VALUE_CHANGED:
2702 /* Stop. */
2703 ++(b->hit_count);
2704 break;
2705 case WP_VALUE_NOT_CHANGED:
2706 /* Don't stop. */
2707 bs->print_it = print_it_noop;
2708 bs->stop = 0;
c5aa993b
JM
2709 continue;
2710 default:
2711 /* Can't happen. */
2712 /* FALLTHROUGH */
2713 case 0:
2714 /* Error from catch_errors. */
2715 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2716 if (b->related_breakpoint)
b5de0fa7
EZ
2717 b->related_breakpoint->disposition = disp_del_at_next_stop;
2718 b->disposition = disp_del_at_next_stop;
c5aa993b
JM
2719 /* We've already printed what needs to be printed. */
2720 bs->print_it = print_it_done;
2721
2722 /* Stop. */
2723 break;
2724 }
2725 }
53a5351d
JM
2726 else if (b->type == bp_read_watchpoint ||
2727 b->type == bp_access_watchpoint)
c5aa993b
JM
2728 {
2729 CORE_ADDR addr;
278cd55f 2730 struct value *v;
c5aa993b
JM
2731 int found = 0;
2732
4aa7a7f5 2733 if (!target_stopped_data_address (&current_target, &addr))
c5aa993b
JM
2734 continue;
2735 for (v = b->val_chain; v; v = v->next)
2736 {
5c44784c
JM
2737 if (VALUE_LVAL (v) == lval_memory
2738 && ! VALUE_LAZY (v))
c5aa993b 2739 {
df407dfe 2740 struct type *vtype = check_typedef (value_type (v));
2e70b7b9
MS
2741
2742 if (v == b->val_chain
2743 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
2744 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
2745 {
2746 CORE_ADDR vaddr;
2747
df407dfe 2748 vaddr = VALUE_ADDRESS (v) + value_offset (v);
2e70b7b9
MS
2749 /* Exact match not required. Within range is
2750 sufficient. */
2751 if (addr >= vaddr &&
df407dfe 2752 addr < vaddr + TYPE_LENGTH (value_type (v)))
2e70b7b9
MS
2753 found = 1;
2754 }
c5aa993b
JM
2755 }
2756 }
2757 if (found)
9ebf4acf
AC
2758 {
2759 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n",
2760 b->number);
2761 struct cleanup *cleanups = make_cleanup (xfree, message);
2762 int e = catch_errors (watchpoint_check, bs, message,
2763 RETURN_MASK_ALL);
2764 do_cleanups (cleanups);
2765 switch (e)
2766 {
2767 case WP_DELETED:
2768 /* We've already printed what needs to be printed. */
2769 bs->print_it = print_it_done;
2770 /* Stop. */
2771 break;
2772 case WP_VALUE_CHANGED:
2773 if (b->type == bp_read_watchpoint)
2774 {
2775 /* Don't stop: read watchpoints shouldn't fire if
2776 the value has changed. This is for targets
2777 which cannot set read-only watchpoints. */
2778 bs->print_it = print_it_noop;
2779 bs->stop = 0;
2780 continue;
2781 }
2782 ++(b->hit_count);
2783 break;
2784 case WP_VALUE_NOT_CHANGED:
2785 /* Stop. */
2786 ++(b->hit_count);
2787 break;
2788 default:
2789 /* Can't happen. */
2790 case 0:
2791 /* Error from catch_errors. */
2792 printf_filtered ("Watchpoint %d deleted.\n", b->number);
2793 if (b->related_breakpoint)
2794 b->related_breakpoint->disposition = disp_del_at_next_stop;
2795 b->disposition = disp_del_at_next_stop;
2796 /* We've already printed what needs to be printed. */
2797 bs->print_it = print_it_done;
2798 break;
2799 }
2800 }
53a5351d
JM
2801 else /* found == 0 */
2802 {
2803 /* This is a case where some watchpoint(s) triggered,
2804 but not at the address of this watchpoint (FOUND
2805 was left zero). So don't print anything for this
2806 watchpoint. */
2807 bs->print_it = print_it_noop;
2808 bs->stop = 0;
2809 continue;
2810 }
c5aa993b
JM
2811 }
2812 else
2813 {
2814 /* By definition, an encountered breakpoint is a triggered
2815 breakpoint. */
2816 ++(b->hit_count);
c906108c 2817
c5aa993b
JM
2818 real_breakpoint = 1;
2819 }
2820
818dd999
AC
2821 if (frame_id_p (b->frame_id)
2822 && !frame_id_eq (b->frame_id, get_frame_id (get_current_frame ())))
c5aa993b
JM
2823 bs->stop = 0;
2824 else
2825 {
2826 int value_is_zero = 0;
2827
2828 if (b->cond)
2829 {
2830 /* Need to select the frame, with all that implies
2831 so that the conditions will have the right context. */
0f7d239c 2832 select_frame (get_current_frame ());
c5aa993b
JM
2833 value_is_zero
2834 = catch_errors (breakpoint_cond_eval, (b->cond),
2835 "Error in testing breakpoint condition:\n",
2836 RETURN_MASK_ALL);
2837 /* FIXME-someday, should give breakpoint # */
2838 free_all_values ();
2839 }
2840 if (b->cond && value_is_zero)
2841 {
2842 bs->stop = 0;
2843 /* Don't consider this a hit. */
2844 --(b->hit_count);
2845 }
fa5281d0
DJ
2846 else if (b->thread != -1 && b->thread != thread_id)
2847 {
2848 bs->stop = 0;
2849 /* Don't consider this a hit. */
2850 --(b->hit_count);
2851 }
c5aa993b
JM
2852 else if (b->ignore_count > 0)
2853 {
2854 b->ignore_count--;
5c44784c 2855 annotate_ignore_count_change ();
c5aa993b
JM
2856 bs->stop = 0;
2857 }
2858 else
2859 {
2860 /* We will stop here */
b5de0fa7
EZ
2861 if (b->disposition == disp_disable)
2862 b->enable_state = bp_disabled;
c5aa993b
JM
2863 if (b->silent)
2864 bs->print = 0;
552f4abf 2865 bs->commands = b->commands;
c5aa993b 2866 if (bs->commands &&
6314a349
AC
2867 (strcmp ("silent", bs->commands->line) == 0
2868 || (xdb_commands && strcmp ("Q", bs->commands->line) == 0)))
c5aa993b
JM
2869 {
2870 bs->commands = bs->commands->next;
c906108c 2871 bs->print = 0;
c5aa993b 2872 }
552f4abf 2873 bs->commands = copy_command_lines (bs->commands);
c5aa993b
JM
2874 }
2875 }
2876 /* Print nothing for this entry if we dont stop or if we dont print. */
2877 if (bs->stop == 0 || bs->print == 0)
2878 bs->print_it = print_it_noop;
2879 }
c906108c
SS
2880
2881 bs->next = NULL; /* Terminate the chain */
2882 bs = root_bs->next; /* Re-grab the head of the chain */
2883
c906108c
SS
2884 /* The value of a hardware watchpoint hasn't changed, but the
2885 intermediate memory locations we are watching may have. */
c5aa993b 2886 if (bs && !bs->stop &&
c906108c
SS
2887 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
2888 bs->breakpoint_at->type == bp_read_watchpoint ||
2889 bs->breakpoint_at->type == bp_access_watchpoint))
2890 {
2891 remove_breakpoints ();
2892 insert_breakpoints ();
2893 }
2894 return bs;
2895}
2896\f
2897/* Tell what to do about this bpstat. */
2898struct bpstat_what
fba45db2 2899bpstat_what (bpstat bs)
c906108c
SS
2900{
2901 /* Classify each bpstat as one of the following. */
c5aa993b
JM
2902 enum class
2903 {
2904 /* This bpstat element has no effect on the main_action. */
2905 no_effect = 0,
2906
2907 /* There was a watchpoint, stop but don't print. */
2908 wp_silent,
c906108c 2909
c5aa993b
JM
2910 /* There was a watchpoint, stop and print. */
2911 wp_noisy,
c906108c 2912
c5aa993b
JM
2913 /* There was a breakpoint but we're not stopping. */
2914 bp_nostop,
c906108c 2915
c5aa993b
JM
2916 /* There was a breakpoint, stop but don't print. */
2917 bp_silent,
c906108c 2918
c5aa993b
JM
2919 /* There was a breakpoint, stop and print. */
2920 bp_noisy,
c906108c 2921
c5aa993b
JM
2922 /* We hit the longjmp breakpoint. */
2923 long_jump,
c906108c 2924
c5aa993b
JM
2925 /* We hit the longjmp_resume breakpoint. */
2926 long_resume,
c906108c 2927
c5aa993b
JM
2928 /* We hit the step_resume breakpoint. */
2929 step_resume,
c906108c 2930
c5aa993b
JM
2931 /* We hit the through_sigtramp breakpoint. */
2932 through_sig,
c906108c 2933
c5aa993b
JM
2934 /* We hit the shared library event breakpoint. */
2935 shlib_event,
c906108c 2936
c5aa993b
JM
2937 /* We caught a shared library event. */
2938 catch_shlib_event,
c906108c 2939
c5aa993b
JM
2940 /* This is just used to count how many enums there are. */
2941 class_last
c906108c
SS
2942 };
2943
2944 /* Here is the table which drives this routine. So that we can
2945 format it pretty, we define some abbreviations for the
2946 enum bpstat_what codes. */
2947#define kc BPSTAT_WHAT_KEEP_CHECKING
2948#define ss BPSTAT_WHAT_STOP_SILENT
2949#define sn BPSTAT_WHAT_STOP_NOISY
2950#define sgl BPSTAT_WHAT_SINGLE
2951#define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
2952#define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
2953#define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
2954#define sr BPSTAT_WHAT_STEP_RESUME
2955#define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
2956#define shl BPSTAT_WHAT_CHECK_SHLIBS
2957#define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
2958
2959/* "Can't happen." Might want to print an error message.
2960 abort() is not out of the question, but chances are GDB is just
2961 a bit confused, not unusable. */
2962#define err BPSTAT_WHAT_STOP_NOISY
2963
2964 /* Given an old action and a class, come up with a new action. */
2965 /* One interesting property of this table is that wp_silent is the same
2966 as bp_silent and wp_noisy is the same as bp_noisy. That is because
2967 after stopping, the check for whether to step over a breakpoint
2968 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
53a5351d
JM
2969 reference to how we stopped. We retain separate wp_silent and
2970 bp_silent codes in case we want to change that someday.
43ff13b4
JM
2971
2972 Another possibly interesting property of this table is that
2973 there's a partial ordering, priority-like, of the actions. Once
2974 you've decided that some action is appropriate, you'll never go
2975 back and decide something of a lower priority is better. The
2976 ordering is:
2977
7e73cedf 2978 kc < clr sgl shl shlr slr sn sr ss ts
c5aa993b
JM
2979 sgl < clrs shl shlr slr sn sr ss ts
2980 slr < err shl shlr sn sr ss ts
2981 clr < clrs err shl shlr sn sr ss ts
2982 clrs < err shl shlr sn sr ss ts
2983 ss < shl shlr sn sr ts
2984 sn < shl shlr sr ts
2985 sr < shl shlr ts
2986 shl < shlr
2987 ts <
2988 shlr <
2989
43ff13b4
JM
2990 What I think this means is that we don't need a damned table
2991 here. If you just put the rows and columns in the right order,
2992 it'd look awfully regular. We could simply walk the bpstat list
2993 and choose the highest priority action we find, with a little
2994 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
2995 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
2996 is messy anyway). */
c906108c
SS
2997
2998 /* step_resume entries: a step resume breakpoint overrides another
2999 breakpoint of signal handling (see comment in wait_for_inferior
fcf70625 3000 at where we set the step_resume breakpoint). */
c906108c
SS
3001 /* We handle the through_sigtramp_breakpoint the same way; having both
3002 one of those and a step_resume_breakpoint is probably very rare (?). */
3003
3004 static const enum bpstat_what_main_action
c5aa993b
JM
3005 table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
3006 {
3007 /* old action */
3008 /* kc ss sn sgl slr clr clrs sr ts shl shlr
3009 */
3010/*no_effect */
3011 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
3012/*wp_silent */
3013 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3014/*wp_noisy */
3015 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3016/*bp_nostop */
3017 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
3018/*bp_silent */
3019 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
3020/*bp_noisy */
3021 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
3022/*long_jump */
a48bb0b3 3023 {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr},
c5aa993b
JM
3024/*long_resume */
3025 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
3026/*step_resume */
3027 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
3028/*through_sig */
3029 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
3030/*shlib */
3031 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
3032/*catch_shlib */
3033 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
3034 };
c906108c
SS
3035
3036#undef kc
3037#undef ss
3038#undef sn
3039#undef sgl
3040#undef slr
3041#undef clr
3042#undef clrs
3043#undef err
3044#undef sr
3045#undef ts
3046#undef shl
3047#undef shlr
3048 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
3049 struct bpstat_what retval;
3050
3051 retval.call_dummy = 0;
3052 for (; bs != NULL; bs = bs->next)
3053 {
3054 enum class bs_class = no_effect;
3055 if (bs->breakpoint_at == NULL)
3056 /* I suspect this can happen if it was a momentary breakpoint
3057 which has since been deleted. */
3058 continue;
3059 switch (bs->breakpoint_at->type)
3060 {
3061 case bp_none:
3062 continue;
3063
3064 case bp_breakpoint:
3065 case bp_hardware_breakpoint:
3066 case bp_until:
3067 case bp_finish:
3068 if (bs->stop)
3069 {
3070 if (bs->print)
3071 bs_class = bp_noisy;
3072 else
3073 bs_class = bp_silent;
3074 }
3075 else
3076 bs_class = bp_nostop;
3077 break;
3078 case bp_watchpoint:
3079 case bp_hardware_watchpoint:
3080 case bp_read_watchpoint:
3081 case bp_access_watchpoint:
3082 if (bs->stop)
3083 {
3084 if (bs->print)
3085 bs_class = wp_noisy;
3086 else
3087 bs_class = wp_silent;
3088 }
3089 else
53a5351d
JM
3090 /* There was a watchpoint, but we're not stopping.
3091 This requires no further action. */
c906108c
SS
3092 bs_class = no_effect;
3093 break;
3094 case bp_longjmp:
3095 bs_class = long_jump;
3096 break;
3097 case bp_longjmp_resume:
3098 bs_class = long_resume;
3099 break;
3100 case bp_step_resume:
3101 if (bs->stop)
3102 {
3103 bs_class = step_resume;
3104 }
3105 else
3106 /* It is for the wrong frame. */
3107 bs_class = bp_nostop;
3108 break;
3109 case bp_through_sigtramp:
3110 bs_class = through_sig;
3111 break;
3112 case bp_watchpoint_scope:
3113 bs_class = bp_nostop;
3114 break;
c5aa993b
JM
3115 case bp_shlib_event:
3116 bs_class = shlib_event;
3117 break;
c4093a6a 3118 case bp_thread_event:
1900040c 3119 case bp_overlay_event:
c4093a6a
JM
3120 bs_class = bp_nostop;
3121 break;
c5aa993b
JM
3122 case bp_catch_load:
3123 case bp_catch_unload:
3124 /* Only if this catchpoint triggered should we cause the
3125 step-out-of-dld behaviour. Otherwise, we ignore this
3126 catchpoint. */
3127 if (bs->stop)
3128 bs_class = catch_shlib_event;
3129 else
3130 bs_class = no_effect;
3131 break;
3132 case bp_catch_fork:
3133 case bp_catch_vfork:
3134 case bp_catch_exec:
3135 if (bs->stop)
3136 {
3137 if (bs->print)
3138 bs_class = bp_noisy;
3139 else
3140 bs_class = bp_silent;
3141 }
3142 else
53a5351d
JM
3143 /* There was a catchpoint, but we're not stopping.
3144 This requires no further action. */
c5aa993b
JM
3145 bs_class = no_effect;
3146 break;
3147 case bp_catch_catch:
3148 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
3149 bs_class = bp_nostop;
3150 else if (bs->stop)
3151 bs_class = bs->print ? bp_noisy : bp_silent;
3152 break;
3153 case bp_catch_throw:
3154 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
3155 bs_class = bp_nostop;
3156 else if (bs->stop)
3157 bs_class = bs->print ? bp_noisy : bp_silent;
c906108c 3158 break;
c906108c 3159 case bp_call_dummy:
53a5351d
JM
3160 /* Make sure the action is stop (silent or noisy),
3161 so infrun.c pops the dummy frame. */
c906108c
SS
3162 bs_class = bp_silent;
3163 retval.call_dummy = 1;
3164 break;
3165 }
c5aa993b 3166 current_action = table[(int) bs_class][(int) current_action];
c906108c
SS
3167 }
3168 retval.main_action = current_action;
3169 return retval;
3170}
3171
3172/* Nonzero if we should step constantly (e.g. watchpoints on machines
3173 without hardware support). This isn't related to a specific bpstat,
3174 just to things like whether watchpoints are set. */
3175
c5aa993b 3176int
fba45db2 3177bpstat_should_step (void)
c906108c
SS
3178{
3179 struct breakpoint *b;
3180 ALL_BREAKPOINTS (b)
468d015d 3181 if (breakpoint_enabled (b) && b->type == bp_watchpoint)
3172dc30 3182 return 1;
c906108c
SS
3183 return 0;
3184}
3185
3186/* Nonzero if there are enabled hardware watchpoints. */
3187int
fba45db2 3188bpstat_have_active_hw_watchpoints (void)
c906108c 3189{
075f6582
DJ
3190 struct bp_location *bpt;
3191 ALL_BP_LOCATIONS (bpt)
468d015d 3192 if (breakpoint_enabled (bpt->owner)
075f6582
DJ
3193 && bpt->inserted
3194 && bpt->loc_type == bp_loc_hardware_watchpoint)
3172dc30 3195 return 1;
c906108c
SS
3196 return 0;
3197}
c906108c 3198\f
c5aa993b 3199
c906108c
SS
3200/* Given a bpstat that records zero or more triggered eventpoints, this
3201 function returns another bpstat which contains only the catchpoints
3202 on that first list, if any. */
3203void
fba45db2 3204bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list)
c5aa993b
JM
3205{
3206 struct bpstats root_bs[1];
3207 bpstat bs = root_bs;
3208 struct breakpoint *ep;
3209 char *dll_pathname;
3210
c906108c
SS
3211 bpstat_clear (cp_list);
3212 root_bs->next = NULL;
c5aa993b
JM
3213
3214 for (; ep_list != NULL; ep_list = ep_list->next)
c906108c
SS
3215 {
3216 /* Is this eventpoint a catchpoint? If not, ignore it. */
3217 ep = ep_list->breakpoint_at;
3218 if (ep == NULL)
c5aa993b
JM
3219 break;
3220 if ((ep->type != bp_catch_load) &&
3221 (ep->type != bp_catch_unload) &&
3222 (ep->type != bp_catch_catch) &&
53a5351d
JM
3223 (ep->type != bp_catch_throw))
3224 /* pai: (temp) ADD fork/vfork here!! */
c5aa993b
JM
3225 continue;
3226
c906108c
SS
3227 /* Yes; add it to the list. */
3228 bs = bpstat_alloc (ep, bs);
3229 *bs = *ep_list;
3230 bs->next = NULL;
3231 bs = root_bs->next;
c5aa993b 3232
c906108c
SS
3233#if defined(SOLIB_ADD)
3234 /* Also, for each triggered catchpoint, tag it with the name of
3235 the library that caused this trigger. (We copy the name now,
3236 because it's only guaranteed to be available NOW, when the
3237 catchpoint triggers. Clients who may wish to know the name
3238 later must get it from the catchpoint itself.) */
3239 if (ep->triggered_dll_pathname != NULL)
b8c9b27d 3240 xfree (ep->triggered_dll_pathname);
c906108c 3241 if (ep->type == bp_catch_load)
39f77062
KB
3242 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
3243 PIDGET (inferior_ptid));
c906108c 3244 else
39f77062
KB
3245 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
3246 PIDGET (inferior_ptid));
c906108c
SS
3247#else
3248 dll_pathname = NULL;
3249#endif
3250 if (dll_pathname)
3251 {
53a5351d
JM
3252 ep->triggered_dll_pathname = (char *)
3253 xmalloc (strlen (dll_pathname) + 1);
c906108c
SS
3254 strcpy (ep->triggered_dll_pathname, dll_pathname);
3255 }
3256 else
3257 ep->triggered_dll_pathname = NULL;
3258 }
c5aa993b 3259
c906108c
SS
3260 *cp_list = bs;
3261}
3262
c4093a6a 3263/* Print B to gdb_stdout. */
c906108c 3264static void
c4093a6a
JM
3265print_one_breakpoint (struct breakpoint *b,
3266 CORE_ADDR *last_addr)
c906108c 3267{
52f0bd74
AC
3268 struct command_line *l;
3269 struct symbol *sym;
c4093a6a
JM
3270 struct ep_type_description
3271 {
3272 enum bptype type;
3273 char *description;
3274 };
3275 static struct ep_type_description bptypes[] =
c906108c 3276 {
c5aa993b
JM
3277 {bp_none, "?deleted?"},
3278 {bp_breakpoint, "breakpoint"},
c906108c 3279 {bp_hardware_breakpoint, "hw breakpoint"},
c5aa993b
JM
3280 {bp_until, "until"},
3281 {bp_finish, "finish"},
3282 {bp_watchpoint, "watchpoint"},
c906108c 3283 {bp_hardware_watchpoint, "hw watchpoint"},
c5aa993b
JM
3284 {bp_read_watchpoint, "read watchpoint"},
3285 {bp_access_watchpoint, "acc watchpoint"},
3286 {bp_longjmp, "longjmp"},
3287 {bp_longjmp_resume, "longjmp resume"},
3288 {bp_step_resume, "step resume"},
3289 {bp_through_sigtramp, "sigtramp"},
3290 {bp_watchpoint_scope, "watchpoint scope"},
3291 {bp_call_dummy, "call dummy"},
3292 {bp_shlib_event, "shlib events"},
c4093a6a 3293 {bp_thread_event, "thread events"},
1900040c 3294 {bp_overlay_event, "overlay events"},
c5aa993b
JM
3295 {bp_catch_load, "catch load"},
3296 {bp_catch_unload, "catch unload"},
3297 {bp_catch_fork, "catch fork"},
3298 {bp_catch_vfork, "catch vfork"},
3299 {bp_catch_exec, "catch exec"},
3300 {bp_catch_catch, "catch catch"},
3301 {bp_catch_throw, "catch throw"}
3302 };
c4093a6a 3303
c5aa993b
JM
3304 static char *bpdisps[] =
3305 {"del", "dstp", "dis", "keep"};
c2c6d25f 3306 static char bpenables[] = "nynny";
c906108c 3307 char wrap_indent[80];
8b93c638
JM
3308 struct ui_stream *stb = ui_out_stream_new (uiout);
3309 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
3b31d625 3310 struct cleanup *bkpt_chain;
c906108c 3311
c4093a6a 3312 annotate_record ();
3b31d625 3313 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
c4093a6a
JM
3314
3315 /* 1 */
3316 annotate_field (0);
8b93c638 3317 ui_out_field_int (uiout, "number", b->number);
c4093a6a
JM
3318
3319 /* 2 */
3320 annotate_field (1);
3321 if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
3322 || ((int) b->type != bptypes[(int) b->type].type))
8e65ff28
AC
3323 internal_error (__FILE__, __LINE__,
3324 "bptypes table does not describe type #%d.",
c4093a6a 3325 (int) b->type);
8b93c638 3326 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
c4093a6a
JM
3327
3328 /* 3 */
3329 annotate_field (2);
8b93c638 3330 ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]);
c4093a6a
JM
3331
3332 /* 4 */
3333 annotate_field (3);
b5de0fa7 3334 ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
8b93c638 3335 ui_out_spaces (uiout, 2);
c4093a6a
JM
3336
3337 /* 5 and 6 */
3338 strcpy (wrap_indent, " ");
3339 if (addressprint)
75ac9d7b
MS
3340 {
3341 if (TARGET_ADDR_BIT <= 32)
3342 strcat (wrap_indent, " ");
3343 else
3344 strcat (wrap_indent, " ");
3345 }
c906108c 3346
3086aeae
DJ
3347 if (b->ops != NULL && b->ops->print_one != NULL)
3348 b->ops->print_one (b, last_addr);
3349 else
3350 switch (b->type)
3351 {
3352 case bp_none:
3353 internal_error (__FILE__, __LINE__,
3354 "print_one_breakpoint: bp_none encountered\n");
3355 break;
c906108c 3356
3086aeae
DJ
3357 case bp_watchpoint:
3358 case bp_hardware_watchpoint:
3359 case bp_read_watchpoint:
3360 case bp_access_watchpoint:
3361 /* Field 4, the address, is omitted (which makes the columns
3362 not line up too nicely with the headers, but the effect
3363 is relatively readable). */
3364 if (addressprint)
3365 ui_out_field_skip (uiout, "addr");
3366 annotate_field (5);
3367 print_expression (b->exp, stb->stream);
3368 ui_out_field_stream (uiout, "what", stb);
3369 break;
3370
3371 case bp_catch_load:
3372 case bp_catch_unload:
3373 /* Field 4, the address, is omitted (which makes the columns
3374 not line up too nicely with the headers, but the effect
3375 is relatively readable). */
3376 if (addressprint)
3377 ui_out_field_skip (uiout, "addr");
3378 annotate_field (5);
3379 if (b->dll_pathname == NULL)
3380 {
3381 ui_out_field_string (uiout, "what", "<any library>");
3382 ui_out_spaces (uiout, 1);
3383 }
3384 else
3385 {
3386 ui_out_text (uiout, "library \"");
3387 ui_out_field_string (uiout, "what", b->dll_pathname);
3388 ui_out_text (uiout, "\" ");
3389 }
3390 break;
3391
3392 case bp_catch_fork:
3393 case bp_catch_vfork:
3394 /* Field 4, the address, is omitted (which makes the columns
3395 not line up too nicely with the headers, but the effect
3396 is relatively readable). */
3397 if (addressprint)
3398 ui_out_field_skip (uiout, "addr");
3399 annotate_field (5);
3400 if (b->forked_inferior_pid != 0)
3401 {
3402 ui_out_text (uiout, "process ");
3403 ui_out_field_int (uiout, "what", b->forked_inferior_pid);
3404 ui_out_spaces (uiout, 1);
3405 }
3406
3407 case bp_catch_exec:
3408 /* Field 4, the address, is omitted (which makes the columns
3409 not line up too nicely with the headers, but the effect
3410 is relatively readable). */
3411 if (addressprint)
3412 ui_out_field_skip (uiout, "addr");
3413 annotate_field (5);
3414 if (b->exec_pathname != NULL)
3415 {
3416 ui_out_text (uiout, "program \"");
3417 ui_out_field_string (uiout, "what", b->exec_pathname);
3418 ui_out_text (uiout, "\" ");
3419 }
3420 break;
3421
3422 case bp_catch_catch:
3423 /* Field 4, the address, is omitted (which makes the columns
3424 not line up too nicely with the headers, but the effect
3425 is relatively readable). */
3426 if (addressprint)
3427 ui_out_field_skip (uiout, "addr");
3428 annotate_field (5);
3429 ui_out_field_string (uiout, "what", "exception catch");
3430 ui_out_spaces (uiout, 1);
3431 break;
3432
3433 case bp_catch_throw:
3434 /* Field 4, the address, is omitted (which makes the columns
3435 not line up too nicely with the headers, but the effect
3436 is relatively readable). */
3437 if (addressprint)
3438 ui_out_field_skip (uiout, "addr");
3439 annotate_field (5);
3440 ui_out_field_string (uiout, "what", "exception throw");
3441 ui_out_spaces (uiout, 1);
3442 break;
3443
3444 case bp_breakpoint:
3445 case bp_hardware_breakpoint:
3446 case bp_until:
3447 case bp_finish:
3448 case bp_longjmp:
3449 case bp_longjmp_resume:
3450 case bp_step_resume:
3451 case bp_through_sigtramp:
3452 case bp_watchpoint_scope:
3453 case bp_call_dummy:
3454 case bp_shlib_event:
3455 case bp_thread_event:
3456 case bp_overlay_event:
3457 if (addressprint)
3458 {
3459 annotate_field (4);
0101ce28 3460 if (b->pending)
d5479188 3461 ui_out_field_string (uiout, "addr", "<PENDING>");
0101ce28
JJ
3462 else
3463 ui_out_field_core_addr (uiout, "addr", b->loc->address);
3086aeae
DJ
3464 }
3465 annotate_field (5);
5cab636d 3466 *last_addr = b->loc->address;
3086aeae
DJ
3467 if (b->source_file)
3468 {
cf3a9e5b 3469 sym = find_pc_sect_function (b->loc->address, b->loc->section);
3086aeae
DJ
3470 if (sym)
3471 {
3472 ui_out_text (uiout, "in ");
3473 ui_out_field_string (uiout, "func",
3474 SYMBOL_PRINT_NAME (sym));
3475 ui_out_wrap_hint (uiout, wrap_indent);
3476 ui_out_text (uiout, " at ");
3477 }
3478 ui_out_field_string (uiout, "file", b->source_file);
3479 ui_out_text (uiout, ":");
3480 ui_out_field_int (uiout, "line", b->line_number);
3481 }
0101ce28
JJ
3482 else if (b->pending)
3483 {
3484 ui_out_field_string (uiout, "pending", b->addr_string);
3485 }
3086aeae
DJ
3486 else
3487 {
5cab636d 3488 print_address_symbolic (b->loc->address, stb->stream, demangle, "");
3086aeae
DJ
3489 ui_out_field_stream (uiout, "at", stb);
3490 }
3491 break;
3492 }
c906108c 3493
c4093a6a
JM
3494 if (b->thread != -1)
3495 {
8b93c638
JM
3496 /* FIXME: This seems to be redundant and lost here; see the
3497 "stop only in" line a little further down. */
3498 ui_out_text (uiout, " thread ");
3499 ui_out_field_int (uiout, "thread", b->thread);
c4093a6a
JM
3500 }
3501
8b93c638 3502 ui_out_text (uiout, "\n");
c4093a6a 3503
818dd999 3504 if (frame_id_p (b->frame_id))
c4093a6a
JM
3505 {
3506 annotate_field (6);
8b93c638 3507 ui_out_text (uiout, "\tstop only in stack frame at ");
818dd999
AC
3508 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
3509 the frame ID. */
d0a55772 3510 ui_out_field_core_addr (uiout, "frame", b->frame_id.stack_addr);
8b93c638 3511 ui_out_text (uiout, "\n");
c4093a6a
JM
3512 }
3513
3514 if (b->cond)
3515 {
3516 annotate_field (7);
8b93c638
JM
3517 ui_out_text (uiout, "\tstop only if ");
3518 print_expression (b->cond, stb->stream);
3519 ui_out_field_stream (uiout, "cond", stb);
3520 ui_out_text (uiout, "\n");
c4093a6a 3521 }
0101ce28
JJ
3522
3523 if (b->pending && b->cond_string)
3524 {
3525 annotate_field (7);
3526 ui_out_text (uiout, "\tstop only if ");
3527 ui_out_field_string (uiout, "cond", b->cond_string);
3528 ui_out_text (uiout, "\n");
3529 }
3530
c4093a6a
JM
3531 if (b->thread != -1)
3532 {
3533 /* FIXME should make an annotation for this */
8b93c638
JM
3534 ui_out_text (uiout, "\tstop only in thread ");
3535 ui_out_field_int (uiout, "thread", b->thread);
3536 ui_out_text (uiout, "\n");
c4093a6a
JM
3537 }
3538
3539 if (show_breakpoint_hit_counts && b->hit_count)
3540 {
3541 /* FIXME should make an annotation for this */
8b93c638
JM
3542 if (ep_is_catchpoint (b))
3543 ui_out_text (uiout, "\tcatchpoint");
3544 else
3545 ui_out_text (uiout, "\tbreakpoint");
3546 ui_out_text (uiout, " already hit ");
3547 ui_out_field_int (uiout, "times", b->hit_count);
3548 if (b->hit_count == 1)
3549 ui_out_text (uiout, " time\n");
3550 else
3551 ui_out_text (uiout, " times\n");
c4093a6a
JM
3552 }
3553
fb40c209
AC
3554 /* Output the count also if it is zero, but only if this is
3555 mi. FIXME: Should have a better test for this. */
9dc5e2a9 3556 if (ui_out_is_mi_like_p (uiout))
fb40c209
AC
3557 if (show_breakpoint_hit_counts && b->hit_count == 0)
3558 ui_out_field_int (uiout, "times", b->hit_count);
8b93c638 3559
c4093a6a
JM
3560 if (b->ignore_count)
3561 {
3562 annotate_field (8);
8b93c638
JM
3563 ui_out_text (uiout, "\tignore next ");
3564 ui_out_field_int (uiout, "ignore", b->ignore_count);
3565 ui_out_text (uiout, " hits\n");
c4093a6a
JM
3566 }
3567
3568 if ((l = b->commands))
3569 {
3b31d625
EZ
3570 struct cleanup *script_chain;
3571
c4093a6a 3572 annotate_field (9);
3b31d625 3573 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script");
8b93c638 3574 print_command_lines (uiout, l, 4);
3b31d625 3575 do_cleanups (script_chain);
c4093a6a 3576 }
3b31d625 3577 do_cleanups (bkpt_chain);
8b93c638 3578 do_cleanups (old_chain);
c4093a6a 3579}
c5aa993b 3580
c4093a6a
JM
3581struct captured_breakpoint_query_args
3582 {
3583 int bnum;
3584 };
c5aa993b 3585
c4093a6a 3586static int
2b65245e 3587do_captured_breakpoint_query (struct ui_out *uiout, void *data)
c4093a6a
JM
3588{
3589 struct captured_breakpoint_query_args *args = data;
52f0bd74 3590 struct breakpoint *b;
c4093a6a
JM
3591 CORE_ADDR dummy_addr = 0;
3592 ALL_BREAKPOINTS (b)
3593 {
3594 if (args->bnum == b->number)
c5aa993b 3595 {
c4093a6a
JM
3596 print_one_breakpoint (b, &dummy_addr);
3597 return GDB_RC_OK;
c5aa993b 3598 }
c4093a6a
JM
3599 }
3600 return GDB_RC_NONE;
3601}
c5aa993b 3602
c4093a6a 3603enum gdb_rc
ce43223b 3604gdb_breakpoint_query (struct ui_out *uiout, int bnum, char **error_message)
c4093a6a
JM
3605{
3606 struct captured_breakpoint_query_args args;
3607 args.bnum = bnum;
3608 /* For the moment we don't trust print_one_breakpoint() to not throw
3609 an error. */
ce43223b
AC
3610 return catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
3611 NULL, error_message, RETURN_MASK_ALL);
c4093a6a 3612}
c5aa993b 3613
7f3b0473
AC
3614/* Return non-zero if B is user settable (breakpoints, watchpoints,
3615 catchpoints, et.al.). */
3616
3617static int
3618user_settable_breakpoint (const struct breakpoint *b)
3619{
3620 return (b->type == bp_breakpoint
3621 || b->type == bp_catch_load
3622 || b->type == bp_catch_unload
3623 || b->type == bp_catch_fork
3624 || b->type == bp_catch_vfork
3625 || b->type == bp_catch_exec
3626 || b->type == bp_catch_catch
3627 || b->type == bp_catch_throw
3628 || b->type == bp_hardware_breakpoint
3629 || b->type == bp_watchpoint
3630 || b->type == bp_read_watchpoint
3631 || b->type == bp_access_watchpoint
3632 || b->type == bp_hardware_watchpoint);
3633}
3634
3635/* Print information on user settable breakpoint (watchpoint, etc)
3636 number BNUM. If BNUM is -1 print all user settable breakpoints.
3637 If ALLFLAG is non-zero, include non- user settable breakpoints. */
c906108c 3638
c4093a6a 3639static void
fba45db2 3640breakpoint_1 (int bnum, int allflag)
c4093a6a 3641{
52f0bd74 3642 struct breakpoint *b;
c4093a6a 3643 CORE_ADDR last_addr = (CORE_ADDR) -1;
7f3b0473 3644 int nr_printable_breakpoints;
3b31d625 3645 struct cleanup *bkpttbl_chain;
c4093a6a 3646
7f3b0473
AC
3647 /* Compute the number of rows in the table. */
3648 nr_printable_breakpoints = 0;
3649 ALL_BREAKPOINTS (b)
3650 if (bnum == -1
3651 || bnum == b->number)
3652 {
3653 if (allflag || user_settable_breakpoint (b))
3654 nr_printable_breakpoints++;
3655 }
3656
8b93c638 3657 if (addressprint)
3b31d625
EZ
3658 bkpttbl_chain
3659 = make_cleanup_ui_out_table_begin_end (uiout, 6, nr_printable_breakpoints,
3660 "BreakpointTable");
8b93c638 3661 else
3b31d625
EZ
3662 bkpttbl_chain
3663 = make_cleanup_ui_out_table_begin_end (uiout, 5, nr_printable_breakpoints,
3664 "BreakpointTable");
8b93c638 3665
7f3b0473 3666 if (nr_printable_breakpoints > 0)
d7faa9e7
AC
3667 annotate_breakpoints_headers ();
3668 if (nr_printable_breakpoints > 0)
3669 annotate_field (0);
3670 ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */
3671 if (nr_printable_breakpoints > 0)
3672 annotate_field (1);
3673 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
3674 if (nr_printable_breakpoints > 0)
3675 annotate_field (2);
3676 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
3677 if (nr_printable_breakpoints > 0)
3678 annotate_field (3);
3679 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
3680 if (addressprint)
7f3b0473 3681 {
d7faa9e7
AC
3682 if (nr_printable_breakpoints > 0)
3683 annotate_field (4);
7f3b0473 3684 if (TARGET_ADDR_BIT <= 32)
b25959ec 3685 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
7f3b0473 3686 else
b25959ec 3687 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
7f3b0473 3688 }
d7faa9e7
AC
3689 if (nr_printable_breakpoints > 0)
3690 annotate_field (5);
3691 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
3692 ui_out_table_body (uiout);
3693 if (nr_printable_breakpoints > 0)
3694 annotate_breakpoints_table ();
7f3b0473 3695
c4093a6a
JM
3696 ALL_BREAKPOINTS (b)
3697 if (bnum == -1
3698 || bnum == b->number)
3699 {
3700 /* We only print out user settable breakpoints unless the
3701 allflag is set. */
7f3b0473
AC
3702 if (allflag || user_settable_breakpoint (b))
3703 print_one_breakpoint (b, &last_addr);
c4093a6a
JM
3704 }
3705
3b31d625 3706 do_cleanups (bkpttbl_chain);
698384cd 3707
7f3b0473 3708 if (nr_printable_breakpoints == 0)
c906108c 3709 {
8b93c638
JM
3710 if (bnum == -1)
3711 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
3712 else
3713 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n",
3714 bnum);
c906108c
SS
3715 }
3716 else
c4093a6a
JM
3717 {
3718 /* Compare against (CORE_ADDR)-1 in case some compiler decides
3719 that a comparison of an unsigned with -1 is always false. */
3720 if (last_addr != (CORE_ADDR) -1)
3721 set_next_address (last_addr);
3722 }
c906108c 3723
c4093a6a
JM
3724 /* FIXME? Should this be moved up so that it is only called when
3725 there have been breakpoints? */
c906108c
SS
3726 annotate_breakpoints_table_end ();
3727}
3728
c906108c 3729static void
fba45db2 3730breakpoints_info (char *bnum_exp, int from_tty)
c906108c
SS
3731{
3732 int bnum = -1;
3733
3734 if (bnum_exp)
bb518678 3735 bnum = parse_and_eval_long (bnum_exp);
c906108c
SS
3736
3737 breakpoint_1 (bnum, 0);
3738}
3739
7a292a7a 3740static void
fba45db2 3741maintenance_info_breakpoints (char *bnum_exp, int from_tty)
c906108c
SS
3742{
3743 int bnum = -1;
3744
3745 if (bnum_exp)
bb518678 3746 bnum = parse_and_eval_long (bnum_exp);
c906108c
SS
3747
3748 breakpoint_1 (bnum, 1);
3749}
3750
c906108c
SS
3751/* Print a message describing any breakpoints set at PC. */
3752
3753static void
fba45db2 3754describe_other_breakpoints (CORE_ADDR pc, asection *section)
c906108c 3755{
52f0bd74
AC
3756 int others = 0;
3757 struct breakpoint *b;
c906108c
SS
3758
3759 ALL_BREAKPOINTS (b)
5cab636d 3760 if (b->loc->address == pc) /* address match / overlay match */
0101ce28 3761 if (!b->pending && (!overlay_debugging || b->loc->section == section))
9f04af04 3762 others++;
c906108c
SS
3763 if (others > 0)
3764 {
3765 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
3766 ALL_BREAKPOINTS (b)
5cab636d 3767 if (b->loc->address == pc) /* address match / overlay match */
0101ce28 3768 if (!b->pending && (!overlay_debugging || b->loc->section == section))
9f04af04
MS
3769 {
3770 others--;
3771 printf_filtered ("%d%s%s ",
3772 b->number,
3773 ((b->enable_state == bp_disabled ||
3774 b->enable_state == bp_shlib_disabled ||
3775 b->enable_state == bp_call_disabled)
3776 ? " (disabled)"
3777 : b->enable_state == bp_permanent
3778 ? " (permanent)"
3779 : ""),
3780 (others > 1) ? ","
3781 : ((others == 1) ? " and" : ""));
3782 }
c906108c
SS
3783 printf_filtered ("also set at pc ");
3784 print_address_numeric (pc, 1, gdb_stdout);
3785 printf_filtered (".\n");
3786 }
3787}
3788\f
3789/* Set the default place to put a breakpoint
3790 for the `break' command with no arguments. */
3791
3792void
fba45db2
KB
3793set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab,
3794 int line)
c906108c
SS
3795{
3796 default_breakpoint_valid = valid;
3797 default_breakpoint_address = addr;
3798 default_breakpoint_symtab = symtab;
3799 default_breakpoint_line = line;
3800}
3801
e4f237da
KB
3802/* Return true iff it is meaningful to use the address member of
3803 BPT. For some breakpoint types, the address member is irrelevant
3804 and it makes no sense to attempt to compare it to other addresses
3805 (or use it for any other purpose either).
3806
3807 More specifically, each of the following breakpoint types will always
3808 have a zero valued address and we don't want check_duplicates() to mark
3809 breakpoints of any of these types to be a duplicate of an actual
3810 breakpoint at address zero:
3811
3812 bp_watchpoint
3813 bp_hardware_watchpoint
3814 bp_read_watchpoint
3815 bp_access_watchpoint
3816 bp_catch_exec
3817 bp_longjmp_resume
3818 bp_catch_fork
3819 bp_catch_vork */
3820
3821static int
3822breakpoint_address_is_meaningful (struct breakpoint *bpt)
3823{
3824 enum bptype type = bpt->type;
3825
3826 return (type != bp_watchpoint
3827 && type != bp_hardware_watchpoint
3828 && type != bp_read_watchpoint
3829 && type != bp_access_watchpoint
3830 && type != bp_catch_exec
3831 && type != bp_longjmp_resume
3832 && type != bp_catch_fork
3833 && type != bp_catch_vfork);
3834}
3835
9f60f21b 3836/* Rescan breakpoints at the same address and section as BPT,
c906108c 3837 marking the first one as "first" and any others as "duplicates".
c2c6d25f 3838 This is so that the bpt instruction is only inserted once.
9f60f21b
JB
3839 If we have a permanent breakpoint at the same place as BPT, make
3840 that one the official one, and the rest as duplicates. */
c906108c
SS
3841
3842static void
9f60f21b 3843check_duplicates (struct breakpoint *bpt)
c906108c 3844{
075f6582 3845 struct bp_location *b;
52f0bd74 3846 int count = 0;
075f6582 3847 struct bp_location *perm_bp = 0;
5cab636d 3848 CORE_ADDR address = bpt->loc->address;
cf3a9e5b 3849 asection *section = bpt->loc->section;
c906108c 3850
e4f237da 3851 if (! breakpoint_address_is_meaningful (bpt))
c906108c
SS
3852 return;
3853
075f6582
DJ
3854 ALL_BP_LOCATIONS (b)
3855 if (b->owner->enable_state != bp_disabled
3856 && b->owner->enable_state != bp_shlib_disabled
0101ce28 3857 && !b->owner->pending
075f6582
DJ
3858 && b->owner->enable_state != bp_call_disabled
3859 && b->address == address /* address / overlay match */
3860 && (!overlay_debugging || b->section == section)
3861 && breakpoint_address_is_meaningful (b->owner))
c5aa993b 3862 {
c2c6d25f 3863 /* Have we found a permanent breakpoint? */
075f6582 3864 if (b->owner->enable_state == bp_permanent)
c2c6d25f
JM
3865 {
3866 perm_bp = b;
3867 break;
3868 }
3869
c5aa993b 3870 count++;
075f6582 3871 b->duplicate = count > 1;
c5aa993b 3872 }
c2c6d25f
JM
3873
3874 /* If we found a permanent breakpoint at this address, go over the
3875 list again and declare all the other breakpoints there to be the
3876 duplicates. */
3877 if (perm_bp)
3878 {
075f6582 3879 perm_bp->duplicate = 0;
c2c6d25f
JM
3880
3881 /* Permanent breakpoint should always be inserted. */
075f6582 3882 if (! perm_bp->inserted)
8e65ff28
AC
3883 internal_error (__FILE__, __LINE__,
3884 "allegedly permanent breakpoint is not "
c2c6d25f
JM
3885 "actually inserted");
3886
075f6582 3887 ALL_BP_LOCATIONS (b)
c2c6d25f
JM
3888 if (b != perm_bp)
3889 {
075f6582
DJ
3890 if (b->owner->enable_state != bp_disabled
3891 && b->owner->enable_state != bp_shlib_disabled
0101ce28 3892 && !b->owner->pending
075f6582
DJ
3893 && b->owner->enable_state != bp_call_disabled
3894 && b->address == address /* address / overlay match */
3895 && (!overlay_debugging || b->section == section)
3896 && breakpoint_address_is_meaningful (b->owner))
3897 {
3898 if (b->inserted)
3899 internal_error (__FILE__, __LINE__,
3900 "another breakpoint was inserted on top of "
3901 "a permanent breakpoint");
3902
3903 b->duplicate = 1;
3904 }
c2c6d25f
JM
3905 }
3906 }
c906108c
SS
3907}
3908
76897487
KB
3909static void
3910breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr,
3911 int bnum, int have_bnum)
3912{
3913 char astr1[40];
3914 char astr2[40];
3915
bb599908
PH
3916 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8));
3917 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8));
76897487
KB
3918 if (have_bnum)
3919 warning ("Breakpoint %d address previously adjusted from %s to %s.",
3920 bnum, astr1, astr2);
3921 else
3922 warning ("Breakpoint address adjusted from %s to %s.", astr1, astr2);
3923}
3924
3925/* Adjust a breakpoint's address to account for architectural constraints
3926 on breakpoint placement. Return the adjusted address. Note: Very
3927 few targets require this kind of adjustment. For most targets,
3928 this function is simply the identity function. */
3929
3930static CORE_ADDR
88f7da05 3931adjust_breakpoint_address (CORE_ADDR bpaddr, enum bptype bptype)
76897487
KB
3932{
3933 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch))
3934 {
3935 /* Very few targets need any kind of breakpoint adjustment. */
3936 return bpaddr;
3937 }
88f7da05
KB
3938 else if (bptype == bp_watchpoint
3939 || bptype == bp_hardware_watchpoint
3940 || bptype == bp_read_watchpoint
3941 || bptype == bp_access_watchpoint
3942 || bptype == bp_catch_fork
3943 || bptype == bp_catch_vfork
3944 || bptype == bp_catch_exec)
3945 {
3946 /* Watchpoints and the various bp_catch_* eventpoints should not
3947 have their addresses modified. */
3948 return bpaddr;
3949 }
76897487
KB
3950 else
3951 {
3952 CORE_ADDR adjusted_bpaddr;
3953
3954 /* Some targets have architectural constraints on the placement
3955 of breakpoint instructions. Obtain the adjusted address. */
3956 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (current_gdbarch,
3957 bpaddr);
3958
3959 /* An adjusted breakpoint address can significantly alter
3960 a user's expectations. Print a warning if an adjustment
3961 is required. */
3962 if (adjusted_bpaddr != bpaddr)
3963 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0);
3964
3965 return adjusted_bpaddr;
3966 }
3967}
3968
7cc221ef
DJ
3969/* Allocate a struct bp_location. */
3970
26bb91f3 3971static struct bp_location *
e049a4b5 3972allocate_bp_location (struct breakpoint *bpt, enum bptype bp_type)
7cc221ef
DJ
3973{
3974 struct bp_location *loc, *loc_p;
3975
3976 loc = xmalloc (sizeof (struct bp_location));
3977 memset (loc, 0, sizeof (*loc));
3978
e049a4b5
DJ
3979 loc->owner = bpt;
3980
3981 switch (bp_type)
3982 {
3983 case bp_breakpoint:
3984 case bp_until:
3985 case bp_finish:
3986 case bp_longjmp:
3987 case bp_longjmp_resume:
3988 case bp_step_resume:
3989 case bp_through_sigtramp:
3990 case bp_watchpoint_scope:
3991 case bp_call_dummy:
3992 case bp_shlib_event:
3993 case bp_thread_event:
3994 case bp_overlay_event:
3995 case bp_catch_load:
3996 case bp_catch_unload:
3997 loc->loc_type = bp_loc_software_breakpoint;
3998 break;
3999 case bp_hardware_breakpoint:
4000 loc->loc_type = bp_loc_hardware_breakpoint;
4001 break;
4002 case bp_hardware_watchpoint:
4003 case bp_read_watchpoint:
4004 case bp_access_watchpoint:
4005 loc->loc_type = bp_loc_hardware_watchpoint;
4006 break;
4007 case bp_watchpoint:
4008 case bp_catch_fork:
4009 case bp_catch_vfork:
4010 case bp_catch_exec:
4011 case bp_catch_catch:
4012 case bp_catch_throw:
4013 loc->loc_type = bp_loc_other;
4014 break;
4015 default:
4016 internal_error (__FILE__, __LINE__, "unknown breakpoint type");
4017 }
4018
7cc221ef
DJ
4019 /* Add this breakpoint to the end of the chain. */
4020
4021 loc_p = bp_location_chain;
4022 if (loc_p == 0)
4023 bp_location_chain = loc;
4024 else
4025 {
4026 while (loc_p->next)
4027 loc_p = loc_p->next;
4028 loc_p->next = loc;
4029 }
4030
4031 return loc;
4032}
4033
4d28f7a8
KB
4034/* set_raw_breakpoint() is a low level routine for allocating and
4035 partially initializing a breakpoint of type BPTYPE. The newly
4036 created breakpoint's address, section, source file name, and line
4037 number are provided by SAL. The newly created and partially
4038 initialized breakpoint is added to the breakpoint chain and
4039 is also returned as the value of this function.
c906108c 4040
4d28f7a8
KB
4041 It is expected that the caller will complete the initialization of
4042 the newly created breakpoint struct as well as output any status
4043 information regarding the creation of a new breakpoint. In
4044 particular, set_raw_breakpoint() does NOT set the breakpoint
4045 number! Care should be taken to not allow an error() to occur
4046 prior to completing the initialization of the breakpoint. If this
4047 should happen, a bogus breakpoint will be left on the chain. */
c906108c
SS
4048
4049struct breakpoint *
4d28f7a8 4050set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
c906108c 4051{
52f0bd74 4052 struct breakpoint *b, *b1;
c906108c
SS
4053
4054 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
4055 memset (b, 0, sizeof (*b));
e049a4b5 4056 b->loc = allocate_bp_location (b, bptype);
5cab636d 4057 b->loc->requested_address = sal.pc;
88f7da05
KB
4058 b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
4059 bptype);
c906108c
SS
4060 if (sal.symtab == NULL)
4061 b->source_file = NULL;
4062 else
4063 b->source_file = savestring (sal.symtab->filename,
4064 strlen (sal.symtab->filename));
cf3a9e5b 4065 b->loc->section = sal.section;
4d28f7a8 4066 b->type = bptype;
c906108c
SS
4067 b->language = current_language->la_language;
4068 b->input_radix = input_radix;
4069 b->thread = -1;
4070 b->line_number = sal.line;
b5de0fa7 4071 b->enable_state = bp_enabled;
c906108c
SS
4072 b->next = 0;
4073 b->silent = 0;
4074 b->ignore_count = 0;
4075 b->commands = NULL;
818dd999 4076 b->frame_id = null_frame_id;
c906108c
SS
4077 b->dll_pathname = NULL;
4078 b->triggered_dll_pathname = NULL;
4079 b->forked_inferior_pid = 0;
4080 b->exec_pathname = NULL;
3086aeae 4081 b->ops = NULL;
0101ce28 4082 b->pending = 0;
c906108c
SS
4083
4084 /* Add this breakpoint to the end of the chain
4085 so that a list of breakpoints will come out in order
4086 of increasing numbers. */
4087
4088 b1 = breakpoint_chain;
4089 if (b1 == 0)
4090 breakpoint_chain = b;
4091 else
4092 {
4093 while (b1->next)
4094 b1 = b1->next;
4095 b1->next = b;
4096 }
4097
9f60f21b 4098 check_duplicates (b);
c906108c
SS
4099 breakpoints_changed ();
4100
4101 return b;
4102}
4103
c2c6d25f
JM
4104
4105/* Note that the breakpoint object B describes a permanent breakpoint
4106 instruction, hard-wired into the inferior's code. */
4107void
4108make_breakpoint_permanent (struct breakpoint *b)
4109{
b5de0fa7 4110 b->enable_state = bp_permanent;
c2c6d25f
JM
4111
4112 /* By definition, permanent breakpoints are already present in the code. */
5cab636d 4113 b->loc->inserted = 1;
c2c6d25f
JM
4114}
4115
1900040c
MS
4116static struct breakpoint *
4117create_internal_breakpoint (CORE_ADDR address, enum bptype type)
4118{
4119 static int internal_breakpoint_number = -1;
4120 struct symtab_and_line sal;
4121 struct breakpoint *b;
4122
fe39c653 4123 init_sal (&sal); /* initialize to zeroes */
1900040c
MS
4124
4125 sal.pc = address;
4126 sal.section = find_pc_overlay (sal.pc);
4127
4128 b = set_raw_breakpoint (sal, type);
4129 b->number = internal_breakpoint_number--;
4130 b->disposition = disp_donttouch;
4131
4132 return b;
4133}
4134
c906108c
SS
4135
4136static void
fba45db2 4137create_longjmp_breakpoint (char *func_name)
c906108c 4138{
c906108c 4139 struct breakpoint *b;
1900040c 4140 struct minimal_symbol *m;
c906108c 4141
1900040c
MS
4142 if (func_name == NULL)
4143 b = create_internal_breakpoint (0, bp_longjmp_resume);
4144 else
c906108c 4145 {
5520a790 4146 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
c906108c 4147 return;
1900040c
MS
4148
4149 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp);
c906108c 4150 }
c906108c 4151
b5de0fa7 4152 b->enable_state = bp_disabled;
c906108c
SS
4153 b->silent = 1;
4154 if (func_name)
4fcf66da 4155 b->addr_string = xstrdup (func_name);
c906108c
SS
4156}
4157
53a5351d
JM
4158/* Call this routine when stepping and nexting to enable a breakpoint
4159 if we do a longjmp(). When we hit that breakpoint, call
c906108c
SS
4160 set_longjmp_resume_breakpoint() to figure out where we are going. */
4161
4162void
fba45db2 4163enable_longjmp_breakpoint (void)
c906108c 4164{
52f0bd74 4165 struct breakpoint *b;
c906108c
SS
4166
4167 ALL_BREAKPOINTS (b)
4168 if (b->type == bp_longjmp)
c5aa993b 4169 {
b5de0fa7 4170 b->enable_state = bp_enabled;
9f60f21b 4171 check_duplicates (b);
c5aa993b 4172 }
c906108c
SS
4173}
4174
4175void
fba45db2 4176disable_longjmp_breakpoint (void)
c906108c 4177{
52f0bd74 4178 struct breakpoint *b;
c906108c
SS
4179
4180 ALL_BREAKPOINTS (b)
c5aa993b 4181 if (b->type == bp_longjmp
c906108c 4182 || b->type == bp_longjmp_resume)
c5aa993b 4183 {
b5de0fa7 4184 b->enable_state = bp_disabled;
9f60f21b 4185 check_duplicates (b);
c5aa993b 4186 }
c906108c
SS
4187}
4188
1900040c
MS
4189static void
4190create_overlay_event_breakpoint (char *func_name)
4191{
4192 struct breakpoint *b;
4193 struct minimal_symbol *m;
4194
5520a790 4195 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL)
1900040c
MS
4196 return;
4197
4198 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m),
4199 bp_overlay_event);
4200 b->addr_string = xstrdup (func_name);
4201
4202 if (overlay_debugging == ovly_auto)
c02f5703
MS
4203 {
4204 b->enable_state = bp_enabled;
4205 overlay_events_enabled = 1;
4206 }
1900040c 4207 else
c02f5703
MS
4208 {
4209 b->enable_state = bp_disabled;
4210 overlay_events_enabled = 0;
4211 }
1900040c
MS
4212}
4213
4214void
4215enable_overlay_breakpoints (void)
4216{
52f0bd74 4217 struct breakpoint *b;
1900040c
MS
4218
4219 ALL_BREAKPOINTS (b)
4220 if (b->type == bp_overlay_event)
4221 {
4222 b->enable_state = bp_enabled;
4223 check_duplicates (b);
c02f5703 4224 overlay_events_enabled = 1;
1900040c
MS
4225 }
4226}
4227
4228void
4229disable_overlay_breakpoints (void)
4230{
52f0bd74 4231 struct breakpoint *b;
1900040c
MS
4232
4233 ALL_BREAKPOINTS (b)
4234 if (b->type == bp_overlay_event)
4235 {
4236 b->enable_state = bp_disabled;
4237 check_duplicates (b);
c02f5703 4238 overlay_events_enabled = 0;
1900040c
MS
4239 }
4240}
4241
c4093a6a 4242struct breakpoint *
fba45db2 4243create_thread_event_breakpoint (CORE_ADDR address)
c4093a6a
JM
4244{
4245 struct breakpoint *b;
c4093a6a 4246
1900040c 4247 b = create_internal_breakpoint (address, bp_thread_event);
c4093a6a 4248
b5de0fa7 4249 b->enable_state = bp_enabled;
c4093a6a 4250 /* addr_string has to be used or breakpoint_re_set will delete me. */
b435e160 4251 b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address));
c4093a6a
JM
4252
4253 return b;
4254}
4255
4256void
4257remove_thread_event_breakpoints (void)
4258{
4259 struct breakpoint *b, *temp;
4260
4261 ALL_BREAKPOINTS_SAFE (b, temp)
4262 if (b->type == bp_thread_event)
4263 delete_breakpoint (b);
4264}
4265
0101ce28
JJ
4266struct captured_parse_breakpoint_args
4267 {
4268 char **arg_p;
4269 struct symtabs_and_lines *sals_p;
4270 char ***addr_string_p;
4271 int *not_found_ptr;
4272 };
4273
4274struct lang_and_radix
4275 {
4276 enum language lang;
4277 int radix;
4278 };
4279
4280/* Cleanup helper routine to restore the current language and
4281 input radix. */
4282static void
4283do_restore_lang_radix_cleanup (void *old)
4284{
4285 struct lang_and_radix *p = old;
4286 set_language (p->lang);
4287 input_radix = p->radix;
4288}
4289
4290/* Try and resolve a pending breakpoint. */
4291static int
4292resolve_pending_breakpoint (struct breakpoint *b)
4293{
4294 /* Try and reparse the breakpoint in case the shared library
4295 is now loaded. */
4296 struct symtabs_and_lines sals;
4297 struct symtab_and_line pending_sal;
4298 char **cond_string = (char **) NULL;
4299 char *copy_arg = b->addr_string;
4300 char **addr_string;
4301 char *errmsg;
4302 int rc;
4303 int not_found = 0;
4304 struct ui_file *old_gdb_stderr;
4305 struct lang_and_radix old_lr;
4306 struct cleanup *old_chain;
4307
4308 /* Set language, input-radix, then reissue breakpoint command.
4309 Ensure the language and input-radix are restored afterwards. */
4310 old_lr.lang = current_language->la_language;
4311 old_lr.radix = input_radix;
4312 old_chain = make_cleanup (do_restore_lang_radix_cleanup, &old_lr);
4313
4314 set_language (b->language);
4315 input_radix = b->input_radix;
4316 rc = break_command_1 (b->addr_string, b->flag, b->from_tty, b);
4317
4318 if (rc == GDB_RC_OK)
4319 /* Pending breakpoint has been resolved. */
4320 printf_filtered ("Pending breakpoint \"%s\" resolved\n", b->addr_string);
4321
4322 do_cleanups (old_chain);
4323 return rc;
4324}
4325
cae688ec
JJ
4326#ifdef SOLIB_ADD
4327void
4328remove_solib_event_breakpoints (void)
4329{
4330 struct breakpoint *b, *temp;
4331
4332 ALL_BREAKPOINTS_SAFE (b, temp)
4333 if (b->type == bp_shlib_event)
4334 delete_breakpoint (b);
4335}
4336
4337struct breakpoint *
4338create_solib_event_breakpoint (CORE_ADDR address)
4339{
4340 struct breakpoint *b;
4341
4342 b = create_internal_breakpoint (address, bp_shlib_event);
4343 return b;
4344}
4345
4346/* Disable any breakpoints that are on code in shared libraries. Only
4347 apply to enabled breakpoints, disabled ones can just stay disabled. */
4348
4349void
4350disable_breakpoints_in_shlibs (int silent)
4351{
4352 struct breakpoint *b;
4353 int disabled_shlib_breaks = 0;
4354
4355 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4356 ALL_BREAKPOINTS (b)
4357 {
4358#if defined (PC_SOLIB)
4359 if (((b->type == bp_breakpoint) ||
4360 (b->type == bp_hardware_breakpoint)) &&
4361 breakpoint_enabled (b) &&
4362 !b->loc->duplicate &&
4363 PC_SOLIB (b->loc->address))
4364 {
4365 b->enable_state = bp_shlib_disabled;
4366 if (!silent)
4367 {
4368 if (!disabled_shlib_breaks)
4369 {
4370 target_terminal_ours_for_output ();
4371 warning ("Temporarily disabling shared library breakpoints:");
4372 }
4373 disabled_shlib_breaks = 1;
4374 warning ("breakpoint #%d ", b->number);
4375 }
4376 }
4377#endif
4378 }
4379}
4380
84acb35a
JJ
4381/* Disable any breakpoints that are in in an unloaded shared library. Only
4382 apply to enabled breakpoints, disabled ones can just stay disabled. */
4383
4384void
4385disable_breakpoints_in_unloaded_shlib (struct so_list *solib)
4386{
4387 struct breakpoint *b;
4388 int disabled_shlib_breaks = 0;
4389
4390#if defined (PC_SOLIB)
4391 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
4392 ALL_BREAKPOINTS (b)
4393 {
4394 if ((b->loc->loc_type == bp_loc_hardware_breakpoint
4395 || b->loc->loc_type == bp_loc_software_breakpoint)
4396 && breakpoint_enabled (b)
4397 && !b->loc->duplicate)
4398 {
4399 char *so_name = PC_SOLIB (b->loc->address);
4400 if (so_name
4401 && !strcmp (so_name, solib->so_name))
4402 {
4403 b->enable_state = bp_shlib_disabled;
4404 /* At this point, we cannot rely on remove_breakpoint
4405 succeeding so we must mark the breakpoint as not inserted
4406 to prevent future errors occurring in remove_breakpoints. */
4407 b->loc->inserted = 0;
4408 if (!disabled_shlib_breaks)
4409 {
4410 target_terminal_ours_for_output ();
4411 warning ("Temporarily disabling breakpoints for unloaded shared library \"%s\"",
4412 so_name);
4413 }
4414 disabled_shlib_breaks = 1;
4415 }
4416 }
4417 }
4418#endif
4419}
4420
c906108c
SS
4421/* Try to reenable any breakpoints in shared libraries. */
4422void
fba45db2 4423re_enable_breakpoints_in_shlibs (void)
c906108c 4424{
0101ce28 4425 struct breakpoint *b, *tmp;
c906108c 4426
0101ce28
JJ
4427 ALL_BREAKPOINTS_SAFE (b, tmp)
4428 {
b5de0fa7 4429 if (b->enable_state == bp_shlib_disabled)
0101ce28
JJ
4430 {
4431 char buf[1], *lib;
4432
4433 /* Do not reenable the breakpoint if the shared library
4434 is still not mapped in. */
4435 lib = PC_SOLIB (b->loc->address);
4436 if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0)
4437 b->enable_state = bp_enabled;
4438 }
4439 else if (b->pending && (b->enable_state == bp_enabled))
4440 {
4441 if (resolve_pending_breakpoint (b) == GDB_RC_OK)
4442 delete_breakpoint (b);
4443 }
4444 }
c906108c
SS
4445}
4446
4447#endif
4448
4449static void
fba45db2
KB
4450solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname,
4451 char *cond_string, enum bptype bp_kind)
c906108c 4452{
c5aa993b 4453 struct breakpoint *b;
c906108c 4454 struct symtabs_and_lines sals;
c5aa993b
JM
4455 struct cleanup *old_chain;
4456 struct cleanup *canonical_strings_chain = NULL;
c5aa993b
JM
4457 char *addr_start = hookname;
4458 char *addr_end = NULL;
4459 char **canonical = (char **) NULL;
4460 int thread = -1; /* All threads. */
4461
1272ad14
MS
4462 /* Set a breakpoint on the specified hook. */
4463 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL,
4464 0, &canonical, NULL);
c906108c 4465 addr_end = hookname;
c5aa993b 4466
c906108c
SS
4467 if (sals.nelts == 0)
4468 {
4469 warning ("Unable to set a breakpoint on dynamic linker callback.");
4470 warning ("Suggest linking with /opt/langtools/lib/end.o.");
4471 warning ("GDB will be unable to track shl_load/shl_unload calls");
4472 return;
4473 }
4474 if (sals.nelts != 1)
4475 {
53a5351d 4476 warning ("Unable to set unique breakpoint on dynamic linker callback.");
c906108c
SS
4477 warning ("GDB will be unable to track shl_load/shl_unload calls");
4478 return;
4479 }
4480
53a5351d
JM
4481 /* Make sure that all storage allocated in decode_line_1 gets freed
4482 in case the following errors out. */
b8c9b27d 4483 old_chain = make_cleanup (xfree, sals.sals);
c5aa993b 4484 if (canonical != (char **) NULL)
c906108c 4485 {
b8c9b27d 4486 make_cleanup (xfree, canonical);
c906108c
SS
4487 canonical_strings_chain = make_cleanup (null_cleanup, 0);
4488 if (canonical[0] != NULL)
b8c9b27d 4489 make_cleanup (xfree, canonical[0]);
c906108c 4490 }
c5aa993b 4491
c906108c 4492 resolve_sal_pc (&sals.sals[0]);
c5aa993b 4493
c906108c 4494 /* Remove the canonical strings from the cleanup, they are needed below. */
c5aa993b 4495 if (canonical != (char **) NULL)
c906108c 4496 discard_cleanups (canonical_strings_chain);
c5aa993b 4497
4d28f7a8 4498 b = set_raw_breakpoint (sals.sals[0], bp_kind);
c906108c
SS
4499 set_breakpoint_count (breakpoint_count + 1);
4500 b->number = breakpoint_count;
4501 b->cond = NULL;
53a5351d
JM
4502 b->cond_string = (cond_string == NULL) ?
4503 NULL : savestring (cond_string, strlen (cond_string));
c906108c 4504 b->thread = thread;
c5aa993b
JM
4505
4506 if (canonical != (char **) NULL && canonical[0] != NULL)
c906108c
SS
4507 b->addr_string = canonical[0];
4508 else if (addr_start)
4509 b->addr_string = savestring (addr_start, addr_end - addr_start);
c5aa993b 4510
b5de0fa7
EZ
4511 b->enable_state = bp_enabled;
4512 b->disposition = tempflag ? disp_del : disp_donttouch;
c5aa993b 4513
c906108c
SS
4514 if (dll_pathname == NULL)
4515 b->dll_pathname = NULL;
4516 else
4517 {
4518 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
4519 strcpy (b->dll_pathname, dll_pathname);
4520 }
c5aa993b 4521
c906108c
SS
4522 mention (b);
4523 do_cleanups (old_chain);
4524}
4525
4526void
fba45db2
KB
4527create_solib_load_event_breakpoint (char *hookname, int tempflag,
4528 char *dll_pathname, char *cond_string)
c906108c 4529{
53a5351d
JM
4530 solib_load_unload_1 (hookname, tempflag, dll_pathname,
4531 cond_string, bp_catch_load);
c906108c
SS
4532}
4533
4534void
fba45db2
KB
4535create_solib_unload_event_breakpoint (char *hookname, int tempflag,
4536 char *dll_pathname, char *cond_string)
c906108c 4537{
1272ad14 4538 solib_load_unload_1 (hookname, tempflag, dll_pathname,
53a5351d 4539 cond_string, bp_catch_unload);
c906108c
SS
4540}
4541
4542static void
fba45db2
KB
4543create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
4544 enum bptype bp_kind)
c906108c 4545{
c5aa993b
JM
4546 struct symtab_and_line sal;
4547 struct breakpoint *b;
4548 int thread = -1; /* All threads. */
4549
fe39c653 4550 init_sal (&sal);
c906108c
SS
4551 sal.pc = 0;
4552 sal.symtab = NULL;
4553 sal.line = 0;
c5aa993b 4554
4d28f7a8 4555 b = set_raw_breakpoint (sal, bp_kind);
c906108c
SS
4556 set_breakpoint_count (breakpoint_count + 1);
4557 b->number = breakpoint_count;
4558 b->cond = NULL;
53a5351d
JM
4559 b->cond_string = (cond_string == NULL) ?
4560 NULL : savestring (cond_string, strlen (cond_string));
c906108c
SS
4561 b->thread = thread;
4562 b->addr_string = NULL;
b5de0fa7
EZ
4563 b->enable_state = bp_enabled;
4564 b->disposition = tempflag ? disp_del : disp_donttouch;
c906108c 4565 b->forked_inferior_pid = 0;
c5aa993b 4566
c906108c
SS
4567 mention (b);
4568}
4569
4570void
fba45db2 4571create_fork_event_catchpoint (int tempflag, char *cond_string)
c906108c
SS
4572{
4573 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
4574}
c5aa993b 4575
c906108c 4576void
fba45db2 4577create_vfork_event_catchpoint (int tempflag, char *cond_string)
c906108c
SS
4578{
4579 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
4580}
4581
4582void
fba45db2 4583create_exec_event_catchpoint (int tempflag, char *cond_string)
c906108c 4584{
c5aa993b
JM
4585 struct symtab_and_line sal;
4586 struct breakpoint *b;
4587 int thread = -1; /* All threads. */
c906108c 4588
fe39c653 4589 init_sal (&sal);
c906108c
SS
4590 sal.pc = 0;
4591 sal.symtab = NULL;
4592 sal.line = 0;
4593
4d28f7a8 4594 b = set_raw_breakpoint (sal, bp_catch_exec);
c906108c
SS
4595 set_breakpoint_count (breakpoint_count + 1);
4596 b->number = breakpoint_count;
4597 b->cond = NULL;
53a5351d
JM
4598 b->cond_string = (cond_string == NULL) ?
4599 NULL : savestring (cond_string, strlen (cond_string));
c906108c
SS
4600 b->thread = thread;
4601 b->addr_string = NULL;
b5de0fa7
EZ
4602 b->enable_state = bp_enabled;
4603 b->disposition = tempflag ? disp_del : disp_donttouch;
c906108c 4604
c906108c
SS
4605 mention (b);
4606}
4607
4608static int
fba45db2 4609hw_breakpoint_used_count (void)
c906108c 4610{
52f0bd74 4611 struct breakpoint *b;
c906108c
SS
4612 int i = 0;
4613
4614 ALL_BREAKPOINTS (b)
c5aa993b 4615 {
b5de0fa7 4616 if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
c5aa993b
JM
4617 i++;
4618 }
c906108c
SS
4619
4620 return i;
4621}
4622
4623static int
fba45db2 4624hw_watchpoint_used_count (enum bptype type, int *other_type_used)
c906108c 4625{
52f0bd74 4626 struct breakpoint *b;
c906108c
SS
4627 int i = 0;
4628
4629 *other_type_used = 0;
4630 ALL_BREAKPOINTS (b)
c5aa993b 4631 {
468d015d 4632 if (breakpoint_enabled (b))
c5aa993b
JM
4633 {
4634 if (b->type == type)
4635 i++;
4636 else if ((b->type == bp_hardware_watchpoint ||
4637 b->type == bp_read_watchpoint ||
468d015d 4638 b->type == bp_access_watchpoint))
c5aa993b
JM
4639 *other_type_used = 1;
4640 }
4641 }
c906108c
SS
4642 return i;
4643}
4644
53a5351d
JM
4645/* Call this after hitting the longjmp() breakpoint. Use this to set
4646 a new breakpoint at the target of the jmp_buf.
c906108c 4647
53a5351d
JM
4648 FIXME - This ought to be done by setting a temporary breakpoint
4649 that gets deleted automatically... */
c906108c
SS
4650
4651void
818dd999 4652set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_id frame_id)
c906108c 4653{
52f0bd74 4654 struct breakpoint *b;
c906108c
SS
4655
4656 ALL_BREAKPOINTS (b)
4657 if (b->type == bp_longjmp_resume)
c5aa993b 4658 {
5cab636d 4659 b->loc->requested_address = pc;
88f7da05
KB
4660 b->loc->address = adjust_breakpoint_address (b->loc->requested_address,
4661 b->type);
b5de0fa7 4662 b->enable_state = bp_enabled;
818dd999 4663 b->frame_id = frame_id;
9f60f21b 4664 check_duplicates (b);
c5aa993b
JM
4665 return;
4666 }
c906108c
SS
4667}
4668
4669void
fba45db2 4670disable_watchpoints_before_interactive_call_start (void)
c906108c 4671{
c5aa993b 4672 struct breakpoint *b;
c906108c
SS
4673
4674 ALL_BREAKPOINTS (b)
c5aa993b
JM
4675 {
4676 if (((b->type == bp_watchpoint)
4677 || (b->type == bp_hardware_watchpoint)
4678 || (b->type == bp_read_watchpoint)
4679 || (b->type == bp_access_watchpoint)
4680 || ep_is_exception_catchpoint (b))
468d015d 4681 && breakpoint_enabled (b))
c5aa993b 4682 {
b5de0fa7 4683 b->enable_state = bp_call_disabled;
9f60f21b 4684 check_duplicates (b);
c5aa993b
JM
4685 }
4686 }
c906108c
SS
4687}
4688
4689void
fba45db2 4690enable_watchpoints_after_interactive_call_stop (void)
c906108c 4691{
c5aa993b 4692 struct breakpoint *b;
c906108c
SS
4693
4694 ALL_BREAKPOINTS (b)
c5aa993b
JM
4695 {
4696 if (((b->type == bp_watchpoint)
4697 || (b->type == bp_hardware_watchpoint)
4698 || (b->type == bp_read_watchpoint)
4699 || (b->type == bp_access_watchpoint)
4700 || ep_is_exception_catchpoint (b))
b5de0fa7 4701 && (b->enable_state == bp_call_disabled))
c5aa993b 4702 {
b5de0fa7 4703 b->enable_state = bp_enabled;
9f60f21b 4704 check_duplicates (b);
c5aa993b
JM
4705 }
4706 }
c906108c
SS
4707}
4708
4709
4710/* Set a breakpoint that will evaporate an end of command
4711 at address specified by SAL.
4712 Restrict it to frame FRAME if FRAME is nonzero. */
4713
4714struct breakpoint *
818dd999 4715set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id,
fba45db2 4716 enum bptype type)
c906108c 4717{
52f0bd74 4718 struct breakpoint *b;
4d28f7a8 4719 b = set_raw_breakpoint (sal, type);
b5de0fa7
EZ
4720 b->enable_state = bp_enabled;
4721 b->disposition = disp_donttouch;
818dd999 4722 b->frame_id = frame_id;
c906108c
SS
4723
4724 /* If we're debugging a multi-threaded program, then we
4725 want momentary breakpoints to be active in only a
4726 single thread of control. */
39f77062
KB
4727 if (in_thread_list (inferior_ptid))
4728 b->thread = pid_to_thread_id (inferior_ptid);
c906108c
SS
4729
4730 return b;
4731}
c906108c 4732\f
c5aa993b 4733
c906108c
SS
4734/* Tell the user we have just set a breakpoint B. */
4735
4736static void
fba45db2 4737mention (struct breakpoint *b)
c906108c
SS
4738{
4739 int say_where = 0;
3b31d625 4740 struct cleanup *old_chain, *ui_out_chain;
8b93c638
JM
4741 struct ui_stream *stb;
4742
4743 stb = ui_out_stream_new (uiout);
b02eeafb 4744 old_chain = make_cleanup_ui_out_stream_delete (stb);
c906108c 4745
9a4105ab
AC
4746 /* FIXME: This is misplaced; mention() is called by things (like
4747 hitting a watchpoint) other than breakpoint creation. It should
4748 be possible to clean this up and at the same time replace the
4749 random calls to breakpoint_changed with this hook, as has already
4750 been done for deprecated_delete_breakpoint_hook and so on. */
4751 if (deprecated_create_breakpoint_hook)
4752 deprecated_create_breakpoint_hook (b);
104c1213 4753 breakpoint_create_event (b->number);
c906108c 4754
3086aeae
DJ
4755 if (b->ops != NULL && b->ops->print_mention != NULL)
4756 b->ops->print_mention (b);
4757 else
4758 switch (b->type)
4759 {
4760 case bp_none:
4761 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
4762 break;
4763 case bp_watchpoint:
4764 ui_out_text (uiout, "Watchpoint ");
4765 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4766 ui_out_field_int (uiout, "number", b->number);
4767 ui_out_text (uiout, ": ");
4768 print_expression (b->exp, stb->stream);
4769 ui_out_field_stream (uiout, "exp", stb);
4770 do_cleanups (ui_out_chain);
4771 break;
4772 case bp_hardware_watchpoint:
4773 ui_out_text (uiout, "Hardware watchpoint ");
4774 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt");
4775 ui_out_field_int (uiout, "number", b->number);
4776 ui_out_text (uiout, ": ");
4777 print_expression (b->exp, stb->stream);
4778 ui_out_field_stream (uiout, "exp", stb);
4779 do_cleanups (ui_out_chain);
4780 break;
4781 case bp_read_watchpoint:
4782 ui_out_text (uiout, "Hardware read watchpoint ");
4783 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt");
4784 ui_out_field_int (uiout, "number", b->number);
4785 ui_out_text (uiout, ": ");
4786 print_expression (b->exp, stb->stream);
4787 ui_out_field_stream (uiout, "exp", stb);
4788 do_cleanups (ui_out_chain);
4789 break;
4790 case bp_access_watchpoint:
4791 ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
4792 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt");
4793 ui_out_field_int (uiout, "number", b->number);
4794 ui_out_text (uiout, ": ");
4795 print_expression (b->exp, stb->stream);
4796 ui_out_field_stream (uiout, "exp", stb);
4797 do_cleanups (ui_out_chain);
4798 break;
4799 case bp_breakpoint:
4800 if (ui_out_is_mi_like_p (uiout))
4801 {
4802 say_where = 0;
4803 break;
4804 }
4805 printf_filtered ("Breakpoint %d", b->number);
4806 say_where = 1;
4807 break;
4808 case bp_hardware_breakpoint:
4809 if (ui_out_is_mi_like_p (uiout))
4810 {
4811 say_where = 0;
4812 break;
4813 }
4814 printf_filtered ("Hardware assisted breakpoint %d", b->number);
4815 say_where = 1;
4816 break;
4817 case bp_catch_load:
4818 case bp_catch_unload:
4819 printf_filtered ("Catchpoint %d (%s %s)",
4820 b->number,
4821 (b->type == bp_catch_load) ? "load" : "unload",
4822 (b->dll_pathname != NULL) ?
4823 b->dll_pathname : "<any library>");
4824 break;
4825 case bp_catch_fork:
4826 case bp_catch_vfork:
4827 printf_filtered ("Catchpoint %d (%s)",
4828 b->number,
4829 (b->type == bp_catch_fork) ? "fork" : "vfork");
4830 break;
4831 case bp_catch_exec:
4832 printf_filtered ("Catchpoint %d (exec)",
4833 b->number);
4834 break;
4835 case bp_catch_catch:
4836 case bp_catch_throw:
4837 printf_filtered ("Catchpoint %d (%s)",
4838 b->number,
4839 (b->type == bp_catch_catch) ? "catch" : "throw");
4840 break;
4841
4842 case bp_until:
4843 case bp_finish:
4844 case bp_longjmp:
4845 case bp_longjmp_resume:
4846 case bp_step_resume:
4847 case bp_through_sigtramp:
4848 case bp_call_dummy:
4849 case bp_watchpoint_scope:
4850 case bp_shlib_event:
4851 case bp_thread_event:
4852 case bp_overlay_event:
4853 break;
4854 }
c906108c 4855
c906108c
SS
4856 if (say_where)
4857 {
0101ce28 4858 if (b->pending)
c906108c 4859 {
0101ce28
JJ
4860 printf_filtered (" (%s) pending.", b->addr_string);
4861 }
4862 else
4863 {
4864 if (addressprint || b->source_file == NULL)
4865 {
4866 printf_filtered (" at ");
4867 print_address_numeric (b->loc->address, 1, gdb_stdout);
4868 }
4869 if (b->source_file)
4870 printf_filtered (": file %s, line %d.",
4871 b->source_file, b->line_number);
c906108c 4872 }
c906108c 4873 }
8b93c638 4874 do_cleanups (old_chain);
9dc5e2a9 4875 if (ui_out_is_mi_like_p (uiout))
fb40c209 4876 return;
c906108c
SS
4877 printf_filtered ("\n");
4878}
c906108c 4879\f
c5aa993b 4880
c3f6f71d
JM
4881/* Add SALS.nelts breakpoints to the breakpoint table. For each
4882 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
4883 COND[i] and COND_STRING[i] values.
4884
0101ce28
JJ
4885 The parameter PENDING_BP points to a pending breakpoint that is
4886 the basis of the breakpoints currently being created. The pending
4887 breakpoint may contain a separate condition string or commands
4888 that were added after the initial pending breakpoint was created.
4889
c3f6f71d
JM
4890 NOTE: If the function succeeds, the caller is expected to cleanup
4891 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
4892 array contents). If the function fails (error() is called), the
4893 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
4894 COND and SALS arrays and each of those arrays contents. */
c906108c
SS
4895
4896static void
c3f6f71d
JM
4897create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
4898 struct expression **cond, char **cond_string,
4899 enum bptype type, enum bpdisp disposition,
0101ce28
JJ
4900 int thread, int ignore_count, int from_tty,
4901 struct breakpoint *pending_bp)
c906108c 4902{
c3f6f71d
JM
4903 if (type == bp_hardware_breakpoint)
4904 {
4905 int i = hw_breakpoint_used_count ();
4906 int target_resources_ok =
4907 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
4908 i + sals.nelts, 0);
4909 if (target_resources_ok == 0)
4910 error ("No hardware breakpoint support in the target.");
4911 else if (target_resources_ok < 0)
4912 error ("Hardware breakpoints used exceeds limit.");
4913 }
c906108c 4914
c3f6f71d
JM
4915 /* Now set all the breakpoints. */
4916 {
4917 int i;
4918 for (i = 0; i < sals.nelts; i++)
4919 {
4920 struct breakpoint *b;
4921 struct symtab_and_line sal = sals.sals[i];
c906108c 4922
c3f6f71d
JM
4923 if (from_tty)
4924 describe_other_breakpoints (sal.pc, sal.section);
4925
4d28f7a8 4926 b = set_raw_breakpoint (sal, type);
c3f6f71d
JM
4927 set_breakpoint_count (breakpoint_count + 1);
4928 b->number = breakpoint_count;
c3f6f71d
JM
4929 b->cond = cond[i];
4930 b->thread = thread;
d8ef46f5
DJ
4931 if (addr_string[i])
4932 b->addr_string = addr_string[i];
4933 else
4934 /* addr_string has to be used or breakpoint_re_set will delete
4935 me. */
b435e160 4936 b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address));
c3f6f71d
JM
4937 b->cond_string = cond_string[i];
4938 b->ignore_count = ignore_count;
b5de0fa7 4939 b->enable_state = bp_enabled;
c3f6f71d 4940 b->disposition = disposition;
0101ce28
JJ
4941 /* If resolving a pending breakpoint, a check must be made to see if
4942 the user has specified a new condition or commands for the
4943 breakpoint. A new condition will override any condition that was
4944 initially specified with the initial breakpoint command. */
4945 if (pending_bp)
4946 {
4947 char *arg;
4948 if (pending_bp->cond_string)
4949 {
4950 arg = pending_bp->cond_string;
4951 b->cond_string = savestring (arg, strlen (arg));
4952 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0);
4953 if (*arg)
4954 error ("Junk at end of pending breakpoint condition expression");
4955 }
4956 /* If there are commands associated with the breakpoint, they should
4957 be copied too. */
4958 if (pending_bp->commands)
4959 b->commands = copy_command_lines (pending_bp->commands);
0a5e7efe
JI
4960
4961 /* We have to copy over the ignore_count and thread as well. */
4962 b->ignore_count = pending_bp->ignore_count;
4963 b->thread = pending_bp->thread;
0101ce28 4964 }
c3f6f71d
JM
4965 mention (b);
4966 }
4967 }
4968}
c906108c 4969
c3f6f71d
JM
4970/* Parse ARG which is assumed to be a SAL specification possibly
4971 followed by conditionals. On return, SALS contains an array of SAL
4972 addresses found. ADDR_STRING contains a vector of (canonical)
4973 address strings. ARG points to the end of the SAL. */
c906108c 4974
b9362cc7 4975static void
c3f6f71d
JM
4976parse_breakpoint_sals (char **address,
4977 struct symtabs_and_lines *sals,
0101ce28
JJ
4978 char ***addr_string,
4979 int *not_found_ptr)
c3f6f71d
JM
4980{
4981 char *addr_start = *address;
4982 *addr_string = NULL;
4983 /* If no arg given, or if first arg is 'if ', use the default
4984 breakpoint. */
4985 if ((*address) == NULL
4986 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
c906108c
SS
4987 {
4988 if (default_breakpoint_valid)
4989 {
c3f6f71d 4990 struct symtab_and_line sal;
fe39c653 4991 init_sal (&sal); /* initialize to zeroes */
c3f6f71d 4992 sals->sals = (struct symtab_and_line *)
c906108c
SS
4993 xmalloc (sizeof (struct symtab_and_line));
4994 sal.pc = default_breakpoint_address;
4995 sal.line = default_breakpoint_line;
4996 sal.symtab = default_breakpoint_symtab;
c5aa993b 4997 sal.section = find_pc_overlay (sal.pc);
c3f6f71d
JM
4998 sals->sals[0] = sal;
4999 sals->nelts = 1;
c906108c
SS
5000 }
5001 else
5002 error ("No default breakpoint address now.");
5003 }
5004 else
5005 {
c906108c 5006 /* Force almost all breakpoints to be in terms of the
c5aa993b
JM
5007 current_source_symtab (which is decode_line_1's default). This
5008 should produce the results we want almost all of the time while
1aeae86e
AF
5009 leaving default_breakpoint_* alone.
5010 ObjC: However, don't match an Objective-C method name which
5011 may have a '+' or '-' succeeded by a '[' */
0378c332 5012
c214a6fd 5013 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
0378c332 5014
c906108c 5015 if (default_breakpoint_valid
0378c332 5016 && (!cursal.symtab
1aeae86e
AF
5017 || ((strchr ("+-", (*address)[0]) != NULL)
5018 && ((*address)[1] != '['))))
c3f6f71d 5019 *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
0101ce28
JJ
5020 default_breakpoint_line, addr_string,
5021 not_found_ptr);
c906108c 5022 else
0101ce28
JJ
5023 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
5024 addr_string, not_found_ptr);
c906108c 5025 }
c3f6f71d
JM
5026 /* For any SAL that didn't have a canonical string, fill one in. */
5027 if (sals->nelts > 0 && *addr_string == NULL)
5028 *addr_string = xcalloc (sals->nelts, sizeof (char **));
5029 if (addr_start != (*address))
c906108c 5030 {
c3f6f71d
JM
5031 int i;
5032 for (i = 0; i < sals->nelts; i++)
c906108c 5033 {
c3f6f71d
JM
5034 /* Add the string if not present. */
5035 if ((*addr_string)[i] == NULL)
5036 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
c906108c
SS
5037 }
5038 }
c3f6f71d 5039}
c906108c 5040
c906108c 5041
c3f6f71d
JM
5042/* Convert each SAL into a real PC. Verify that the PC can be
5043 inserted as a breakpoint. If it can't throw an error. */
c906108c 5044
b9362cc7 5045static void
c3f6f71d
JM
5046breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
5047 char *address)
5048{
5049 int i;
5050 for (i = 0; i < sals->nelts; i++)
5051 {
5052 resolve_sal_pc (&sals->sals[i]);
c906108c
SS
5053
5054 /* It's possible for the PC to be nonzero, but still an illegal
5055 value on some targets.
5056
5057 For example, on HP-UX if you start gdb, and before running the
5058 inferior you try to set a breakpoint on a shared library function
5059 "foo" where the inferior doesn't call "foo" directly but does
5060 pass its address to another function call, then we do find a
5061 minimal symbol for the "foo", but it's address is invalid.
5062 (Appears to be an index into a table that the loader sets up
5063 when the inferior is run.)
5064
5065 Give the target a chance to bless sals.sals[i].pc before we
5066 try to make a breakpoint for it. */
45b75230
AC
5067#ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE
5068 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
c5aa993b 5069 {
c3f6f71d
JM
5070 if (address == NULL)
5071 error ("Cannot break without a running program.");
5072 else
5073 error ("Cannot break on %s without a running program.",
5074 address);
c5aa993b 5075 }
45b75230 5076#endif
c3f6f71d
JM
5077 }
5078}
5079
05ff989b 5080static void
0101ce28
JJ
5081do_captured_parse_breakpoint (struct ui_out *ui, void *data)
5082{
5083 struct captured_parse_breakpoint_args *args = data;
5084
5085 parse_breakpoint_sals (args->arg_p, args->sals_p, args->addr_string_p,
5086 args->not_found_ptr);
0101ce28
JJ
5087}
5088
c3f6f71d
JM
5089/* Set a breakpoint according to ARG (function, linenum or *address)
5090 flag: first bit : 0 non-temporary, 1 temporary.
0101ce28 5091 second bit : 0 normal breakpoint, 1 hardware breakpoint.
c5aa993b 5092
0101ce28
JJ
5093 PENDING_BP is non-NULL when this function is being called to resolve
5094 a pending breakpoint. */
5095
5096static int
5097break_command_1 (char *arg, int flag, int from_tty, struct breakpoint *pending_bp)
c3f6f71d 5098{
05ff989b 5099 struct exception e;
c3f6f71d
JM
5100 int tempflag, hardwareflag;
5101 struct symtabs_and_lines sals;
52f0bd74 5102 struct expression **cond = 0;
0101ce28 5103 struct symtab_and_line pending_sal;
c3f6f71d 5104 char **cond_string = (char **) NULL;
0101ce28
JJ
5105 char *copy_arg;
5106 char *err_msg;
c3f6f71d
JM
5107 char *addr_start = arg;
5108 char **addr_string;
5109 struct cleanup *old_chain;
5110 struct cleanup *breakpoint_chain = NULL;
0101ce28 5111 struct captured_parse_breakpoint_args parse_args;
05ff989b 5112 int i;
0101ce28 5113 int pending = 0;
c3f6f71d
JM
5114 int thread = -1;
5115 int ignore_count = 0;
0101ce28 5116 int not_found = 0;
c3f6f71d
JM
5117
5118 hardwareflag = flag & BP_HARDWAREFLAG;
5119 tempflag = flag & BP_TEMPFLAG;
c906108c 5120
c3f6f71d
JM
5121 sals.sals = NULL;
5122 sals.nelts = 0;
5123 addr_string = NULL;
c3f6f71d 5124
0101ce28
JJ
5125 parse_args.arg_p = &arg;
5126 parse_args.sals_p = &sals;
5127 parse_args.addr_string_p = &addr_string;
5128 parse_args.not_found_ptr = &not_found;
5129
05ff989b
AC
5130 e = catch_exception (uiout, do_captured_parse_breakpoint,
5131 &parse_args, RETURN_MASK_ALL);
0101ce28
JJ
5132
5133 /* If caller is interested in rc value from parse, set value. */
05ff989b 5134 switch (e.reason)
0101ce28 5135 {
05ff989b
AC
5136 case RETURN_QUIT:
5137 exception_print (gdb_stderr, NULL, e);
5138 return e.reason;
5139 case RETURN_ERROR:
5140 switch (e.error)
0101ce28 5141 {
05ff989b
AC
5142 case NOT_FOUND_ERROR:
5143 /* If called to resolve pending breakpoint, just return
5144 error code. */
0101ce28 5145 if (pending_bp)
05ff989b 5146 return e.reason;
0101ce28 5147
05ff989b 5148 exception_print (gdb_stderr, NULL, e);
fa8d40ab 5149
05ff989b
AC
5150 /* If pending breakpoint support is turned off, throw
5151 error. */
fa8d40ab
JJ
5152
5153 if (pending_break_support == AUTO_BOOLEAN_FALSE)
2a78bfb5 5154 throw_reason (RETURN_ERROR);
fa8d40ab 5155
05ff989b
AC
5156 /* If pending breakpoint support is auto query and the user
5157 selects no, then simply return the error code. */
fa8d40ab
JJ
5158 if (pending_break_support == AUTO_BOOLEAN_AUTO &&
5159 !nquery ("Make breakpoint pending on future shared library load? "))
05ff989b 5160 return e.reason;
fa8d40ab 5161
05ff989b
AC
5162 /* At this point, either the user was queried about setting
5163 a pending breakpoint and selected yes, or pending
5164 breakpoint behavior is on and thus a pending breakpoint
5165 is defaulted on behalf of the user. */
0101ce28
JJ
5166 copy_arg = xstrdup (addr_start);
5167 addr_string = &copy_arg;
5168 sals.nelts = 1;
5169 sals.sals = &pending_sal;
5170 pending_sal.pc = 0;
5171 pending = 1;
05ff989b
AC
5172 break;
5173 default:
5174 exception_print (gdb_stderr, NULL, e);
5175 return e.reason;
0101ce28 5176 }
05ff989b
AC
5177 default:
5178 if (!sals.nelts)
5179 return GDB_RC_FAIL;
0101ce28 5180 }
c3f6f71d
JM
5181
5182 /* Create a chain of things that always need to be cleaned up. */
5183 old_chain = make_cleanup (null_cleanup, 0);
5184
0101ce28
JJ
5185 if (!pending)
5186 {
5187 /* Make sure that all storage allocated to SALS gets freed. */
5188 make_cleanup (xfree, sals.sals);
5189
5190 /* Cleanup the addr_string array but not its contents. */
5191 make_cleanup (xfree, addr_string);
5192 }
c3f6f71d
JM
5193
5194 /* Allocate space for all the cond expressions. */
5195 cond = xcalloc (sals.nelts, sizeof (struct expression *));
b8c9b27d 5196 make_cleanup (xfree, cond);
c3f6f71d
JM
5197
5198 /* Allocate space for all the cond strings. */
5199 cond_string = xcalloc (sals.nelts, sizeof (char **));
b8c9b27d 5200 make_cleanup (xfree, cond_string);
c3f6f71d
JM
5201
5202 /* ----------------------------- SNIP -----------------------------
5203 Anything added to the cleanup chain beyond this point is assumed
5204 to be part of a breakpoint. If the breakpoint create succeeds
5205 then the memory is not reclaimed. */
5206 breakpoint_chain = make_cleanup (null_cleanup, 0);
5207
5208 /* Mark the contents of the addr_string for cleanup. These go on
5209 the breakpoint_chain and only occure if the breakpoint create
5210 fails. */
5211 for (i = 0; i < sals.nelts; i++)
5212 {
5213 if (addr_string[i] != NULL)
b8c9b27d 5214 make_cleanup (xfree, addr_string[i]);
c3f6f71d
JM
5215 }
5216
5217 /* Resolve all line numbers to PC's and verify that the addresses
5218 are ok for the target. */
0101ce28
JJ
5219 if (!pending)
5220 breakpoint_sals_to_pc (&sals, addr_start);
c3f6f71d
JM
5221
5222 /* Verify that condition can be parsed, before setting any
5223 breakpoints. Allocate a separate condition expression for each
5224 breakpoint. */
5225 thread = -1; /* No specific thread yet */
0101ce28 5226 if (!pending)
c3f6f71d 5227 {
0101ce28 5228 for (i = 0; i < sals.nelts; i++)
c906108c 5229 {
0101ce28
JJ
5230 char *tok = arg;
5231 while (tok && *tok)
c906108c 5232 {
0101ce28
JJ
5233 char *end_tok;
5234 int toklen;
5235 char *cond_start = NULL;
5236 char *cond_end = NULL;
5237 while (*tok == ' ' || *tok == '\t')
5238 tok++;
5239
5240 end_tok = tok;
5241
5242 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5243 end_tok++;
5244
5245 toklen = end_tok - tok;
5246
5247 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5248 {
5249 tok = cond_start = end_tok + 1;
5250 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc),
5251 0);
5252 make_cleanup (xfree, cond[i]);
5253 cond_end = tok;
5254 cond_string[i] = savestring (cond_start,
5255 cond_end - cond_start);
5256 make_cleanup (xfree, cond_string[i]);
5257 }
5258 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
5259 {
5260 char *tmptok;
5261
5262 tok = end_tok + 1;
5263 tmptok = tok;
5264 thread = strtol (tok, &tok, 0);
5265 if (tok == tmptok)
5266 error ("Junk after thread keyword.");
5267 if (!valid_thread_id (thread))
5268 error ("Unknown thread %d\n", thread);
5269 }
5270 else
5271 error ("Junk at end of arguments.");
c906108c 5272 }
c906108c 5273 }
0101ce28
JJ
5274 create_breakpoints (sals, addr_string, cond, cond_string,
5275 hardwareflag ? bp_hardware_breakpoint
5276 : bp_breakpoint,
5277 tempflag ? disp_del : disp_donttouch,
5278 thread, ignore_count, from_tty,
5279 pending_bp);
c906108c 5280 }
0101ce28
JJ
5281 else
5282 {
5283 struct symtab_and_line sal;
5284 struct breakpoint *b;
5285
5286 sal.symtab = NULL;
5287 sal.pc = 0;
5288
5289 make_cleanup (xfree, copy_arg);
5290
5291 b = set_raw_breakpoint (sal, hardwareflag ? bp_hardware_breakpoint
5292 : bp_breakpoint);
5293 set_breakpoint_count (breakpoint_count + 1);
5294 b->number = breakpoint_count;
5295 b->cond = *cond;
5296 b->thread = thread;
5297 b->addr_string = *addr_string;
5298 b->cond_string = *cond_string;
5299 b->ignore_count = ignore_count;
5300 b->pending = 1;
5301 b->disposition = tempflag ? disp_del : disp_donttouch;
5302 b->from_tty = from_tty;
5303 b->flag = flag;
5304 mention (b);
5305 }
5306
c3f6f71d
JM
5307 if (sals.nelts > 1)
5308 {
5309 warning ("Multiple breakpoints were set.");
5310 warning ("Use the \"delete\" command to delete unwanted breakpoints.");
c906108c 5311 }
c3f6f71d
JM
5312 /* That's it. Discard the cleanups for data inserted into the
5313 breakpoint. */
5314 discard_cleanups (breakpoint_chain);
5315 /* But cleanup everything else. */
5316 do_cleanups (old_chain);
0101ce28
JJ
5317
5318 return GDB_RC_OK;
c3f6f71d 5319}
c906108c 5320
c3f6f71d
JM
5321/* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
5322 linenum or *address) with COND and IGNORE_COUNT. */
c906108c 5323
c3f6f71d
JM
5324struct captured_breakpoint_args
5325 {
5326 char *address;
5327 char *condition;
5328 int hardwareflag;
5329 int tempflag;
5330 int thread;
5331 int ignore_count;
5332 };
5333
5334static int
ce43223b 5335do_captured_breakpoint (struct ui_out *uiout, void *data)
c3f6f71d
JM
5336{
5337 struct captured_breakpoint_args *args = data;
5338 struct symtabs_and_lines sals;
52f0bd74 5339 struct expression **cond;
c3f6f71d
JM
5340 struct cleanup *old_chain;
5341 struct cleanup *breakpoint_chain = NULL;
5342 int i;
5343 char **addr_string;
5344 char **cond_string;
5345
5346 char *address_end;
5347
5348 /* Parse the source and lines spec. Delay check that the expression
5349 didn't contain trailing garbage until after cleanups are in
5350 place. */
5351 sals.sals = NULL;
5352 sals.nelts = 0;
5353 address_end = args->address;
5354 addr_string = NULL;
0101ce28 5355 parse_breakpoint_sals (&address_end, &sals, &addr_string, 0);
c3f6f71d
JM
5356
5357 if (!sals.nelts)
5358 return GDB_RC_NONE;
5359
5360 /* Create a chain of things at always need to be cleaned up. */
5361 old_chain = make_cleanup (null_cleanup, 0);
5362
5363 /* Always have a addr_string array, even if it is empty. */
b8c9b27d 5364 make_cleanup (xfree, addr_string);
c3f6f71d
JM
5365
5366 /* Make sure that all storage allocated to SALS gets freed. */
b8c9b27d 5367 make_cleanup (xfree, sals.sals);
c3f6f71d
JM
5368
5369 /* Allocate space for all the cond expressions. */
5370 cond = xcalloc (sals.nelts, sizeof (struct expression *));
b8c9b27d 5371 make_cleanup (xfree, cond);
c3f6f71d
JM
5372
5373 /* Allocate space for all the cond strings. */
5374 cond_string = xcalloc (sals.nelts, sizeof (char **));
b8c9b27d 5375 make_cleanup (xfree, cond_string);
c3f6f71d
JM
5376
5377 /* ----------------------------- SNIP -----------------------------
5378 Anything added to the cleanup chain beyond this point is assumed
5379 to be part of a breakpoint. If the breakpoint create goes
5380 through then that memory is not cleaned up. */
5381 breakpoint_chain = make_cleanup (null_cleanup, 0);
5382
5383 /* Mark the contents of the addr_string for cleanup. These go on
5384 the breakpoint_chain and only occure if the breakpoint create
5385 fails. */
c906108c
SS
5386 for (i = 0; i < sals.nelts; i++)
5387 {
c3f6f71d 5388 if (addr_string[i] != NULL)
b8c9b27d 5389 make_cleanup (xfree, addr_string[i]);
c906108c
SS
5390 }
5391
c3f6f71d
JM
5392 /* Wait until now before checking for garbage at the end of the
5393 address. That way cleanups can take care of freeing any
5394 memory. */
5395 if (*address_end != '\0')
5396 error ("Garbage %s following breakpoint address", address_end);
5397
5398 /* Resolve all line numbers to PC's. */
5399 breakpoint_sals_to_pc (&sals, args->address);
5400
5401 /* Verify that conditions can be parsed, before setting any
5402 breakpoints. */
5403 for (i = 0; i < sals.nelts; i++)
c906108c 5404 {
c3f6f71d
JM
5405 if (args->condition != NULL)
5406 {
5407 char *tok = args->condition;
5408 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
5409 if (*tok != '\0')
5410 error ("Garbage %s follows condition", tok);
b8c9b27d 5411 make_cleanup (xfree, cond[i]);
c3f6f71d
JM
5412 cond_string[i] = xstrdup (args->condition);
5413 }
c906108c 5414 }
c3f6f71d
JM
5415
5416 create_breakpoints (sals, addr_string, cond, cond_string,
5417 args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
b5de0fa7 5418 args->tempflag ? disp_del : disp_donttouch,
0101ce28
JJ
5419 args->thread, args->ignore_count, 0/*from-tty*/,
5420 NULL/*pending_bp*/);
c3f6f71d
JM
5421
5422 /* That's it. Discard the cleanups for data inserted into the
5423 breakpoint. */
5424 discard_cleanups (breakpoint_chain);
5425 /* But cleanup everything else. */
c906108c 5426 do_cleanups (old_chain);
c3f6f71d 5427 return GDB_RC_OK;
c906108c
SS
5428}
5429
c3f6f71d
JM
5430enum gdb_rc
5431gdb_breakpoint (char *address, char *condition,
5432 int hardwareflag, int tempflag,
ce43223b
AC
5433 int thread, int ignore_count,
5434 char **error_message)
c3f6f71d
JM
5435{
5436 struct captured_breakpoint_args args;
5437 args.address = address;
5438 args.condition = condition;
5439 args.hardwareflag = hardwareflag;
5440 args.tempflag = tempflag;
5441 args.thread = thread;
5442 args.ignore_count = ignore_count;
ce43223b
AC
5443 return catch_exceptions_with_msg (uiout, do_captured_breakpoint, &args,
5444 NULL, error_message, RETURN_MASK_ALL);
c3f6f71d
JM
5445}
5446
5447
c906108c
SS
5448/* Helper function for break_command_1 and disassemble_command. */
5449
5450void
fba45db2 5451resolve_sal_pc (struct symtab_and_line *sal)
c906108c
SS
5452{
5453 CORE_ADDR pc;
5454
5455 if (sal->pc == 0 && sal->symtab != NULL)
5456 {
5457 if (!find_line_pc (sal->symtab, sal->line, &pc))
5458 error ("No line %d in file \"%s\".",
5459 sal->line, sal->symtab->filename);
5460 sal->pc = pc;
5461 }
5462
5463 if (sal->section == 0 && sal->symtab != NULL)
5464 {
5465 struct blockvector *bv;
c5aa993b
JM
5466 struct block *b;
5467 struct symbol *sym;
5468 int index;
c906108c 5469
c5aa993b 5470 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
c906108c
SS
5471 if (bv != NULL)
5472 {
c5aa993b 5473 b = BLOCKVECTOR_BLOCK (bv, index);
c906108c
SS
5474 sym = block_function (b);
5475 if (sym != NULL)
5476 {
5477 fixup_symbol_section (sym, sal->symtab->objfile);
5478 sal->section = SYMBOL_BFD_SECTION (sym);
5479 }
5480 else
5481 {
5482 /* It really is worthwhile to have the section, so we'll just
c5aa993b
JM
5483 have to look harder. This case can be executed if we have
5484 line numbers but no functions (as can happen in assembly
5485 source). */
c906108c 5486
c5aa993b 5487 struct minimal_symbol *msym;
c906108c
SS
5488
5489 msym = lookup_minimal_symbol_by_pc (sal->pc);
5490 if (msym)
5491 sal->section = SYMBOL_BFD_SECTION (msym);
5492 }
5493 }
5494 }
5495}
5496
5497void
fba45db2 5498break_command (char *arg, int from_tty)
c906108c 5499{
0101ce28 5500 break_command_1 (arg, 0, from_tty, NULL);
c906108c
SS
5501}
5502
c906108c 5503void
fba45db2 5504tbreak_command (char *arg, int from_tty)
c906108c 5505{
0101ce28 5506 break_command_1 (arg, BP_TEMPFLAG, from_tty, NULL);
c906108c
SS
5507}
5508
c906108c 5509static void
fba45db2 5510hbreak_command (char *arg, int from_tty)
c906108c 5511{
0101ce28 5512 break_command_1 (arg, BP_HARDWAREFLAG, from_tty, NULL);
c906108c
SS
5513}
5514
5515static void
fba45db2 5516thbreak_command (char *arg, int from_tty)
c906108c 5517{
0101ce28 5518 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty, NULL);
c906108c
SS
5519}
5520
5521static void
fba45db2 5522stop_command (char *arg, int from_tty)
c906108c
SS
5523{
5524 printf_filtered ("Specify the type of breakpoint to set.\n\
5525Usage: stop in <function | address>\n\
5526 stop at <line>\n");
5527}
5528
5529static void
fba45db2 5530stopin_command (char *arg, int from_tty)
c906108c
SS
5531{
5532 int badInput = 0;
5533
c5aa993b 5534 if (arg == (char *) NULL)
c906108c
SS
5535 badInput = 1;
5536 else if (*arg != '*')
5537 {
5538 char *argptr = arg;
5539 int hasColon = 0;
5540
53a5351d
JM
5541 /* look for a ':'. If this is a line number specification, then
5542 say it is bad, otherwise, it should be an address or
5543 function/method name */
c906108c 5544 while (*argptr && !hasColon)
c5aa993b
JM
5545 {
5546 hasColon = (*argptr == ':');
5547 argptr++;
5548 }
c906108c
SS
5549
5550 if (hasColon)
c5aa993b 5551 badInput = (*argptr != ':'); /* Not a class::method */
c906108c 5552 else
c5aa993b 5553 badInput = isdigit (*arg); /* a simple line number */
c906108c
SS
5554 }
5555
5556 if (badInput)
c5aa993b 5557 printf_filtered ("Usage: stop in <function | address>\n");
c906108c 5558 else
0101ce28 5559 break_command_1 (arg, 0, from_tty, NULL);
c906108c
SS
5560}
5561
5562static void
fba45db2 5563stopat_command (char *arg, int from_tty)
c906108c
SS
5564{
5565 int badInput = 0;
5566
c5aa993b 5567 if (arg == (char *) NULL || *arg == '*') /* no line number */
c906108c
SS
5568 badInput = 1;
5569 else
5570 {
5571 char *argptr = arg;
5572 int hasColon = 0;
5573
5574 /* look for a ':'. If there is a '::' then get out, otherwise
c5aa993b 5575 it is probably a line number. */
c906108c 5576 while (*argptr && !hasColon)
c5aa993b
JM
5577 {
5578 hasColon = (*argptr == ':');
5579 argptr++;
5580 }
c906108c
SS
5581
5582 if (hasColon)
c5aa993b 5583 badInput = (*argptr == ':'); /* we have class::method */
c906108c 5584 else
c5aa993b 5585 badInput = !isdigit (*arg); /* not a line number */
c906108c
SS
5586 }
5587
5588 if (badInput)
c5aa993b 5589 printf_filtered ("Usage: stop at <line>\n");
c906108c 5590 else
0101ce28 5591 break_command_1 (arg, 0, from_tty, NULL);
c906108c
SS
5592}
5593
53a5351d
JM
5594/* accessflag: hw_write: watch write,
5595 hw_read: watch read,
5596 hw_access: watch access (read or write) */
c906108c 5597static void
fba45db2 5598watch_command_1 (char *arg, int accessflag, int from_tty)
c906108c
SS
5599{
5600 struct breakpoint *b;
5601 struct symtab_and_line sal;
5602 struct expression *exp;
5603 struct block *exp_valid_block;
5604 struct value *val, *mark;
5605 struct frame_info *frame;
5606 struct frame_info *prev_frame = NULL;
5607 char *exp_start = NULL;
5608 char *exp_end = NULL;
5609 char *tok, *end_tok;
5610 int toklen;
5611 char *cond_start = NULL;
5612 char *cond_end = NULL;
5613 struct expression *cond = NULL;
5614 int i, other_type_used, target_resources_ok = 0;
5615 enum bptype bp_type;
5616 int mem_cnt = 0;
5617
fe39c653 5618 init_sal (&sal); /* initialize to zeroes */
c5aa993b 5619
c906108c
SS
5620 /* Parse arguments. */
5621 innermost_block = NULL;
5622 exp_start = arg;
5623 exp = parse_exp_1 (&arg, 0, 0);
5624 exp_end = arg;
5625 exp_valid_block = innermost_block;
5626 mark = value_mark ();
5627 val = evaluate_expression (exp);
5628 release_value (val);
5629 if (VALUE_LAZY (val))
5630 value_fetch_lazy (val);
5631
5632 tok = arg;
5633 while (*tok == ' ' || *tok == '\t')
5634 tok++;
5635 end_tok = tok;
5636
5637 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
5638 end_tok++;
5639
5640 toklen = end_tok - tok;
5641 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
5642 {
5643 tok = cond_start = end_tok + 1;
5644 cond = parse_exp_1 (&tok, 0, 0);
5645 cond_end = tok;
5646 }
5647 if (*tok)
c5aa993b 5648 error ("Junk at end of command.");
c906108c 5649
53a5351d 5650 if (accessflag == hw_read)
c5aa993b 5651 bp_type = bp_read_watchpoint;
53a5351d 5652 else if (accessflag == hw_access)
c5aa993b
JM
5653 bp_type = bp_access_watchpoint;
5654 else
5655 bp_type = bp_hardware_watchpoint;
c906108c
SS
5656
5657 mem_cnt = can_use_hardware_watchpoint (val);
5658 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
5659 error ("Expression cannot be implemented with read/access watchpoint.");
c5aa993b
JM
5660 if (mem_cnt != 0)
5661 {
5662 i = hw_watchpoint_used_count (bp_type, &other_type_used);
53a5351d
JM
5663 target_resources_ok =
5664 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt,
5665 other_type_used);
c5aa993b 5666 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
53a5351d
JM
5667 error ("Target does not support this type of hardware watchpoint.");
5668
c5aa993b 5669 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
53a5351d 5670 error ("Target can only support one kind of HW watchpoint at a time.");
c5aa993b 5671 }
c906108c
SS
5672
5673#if defined(HPUXHPPA)
c5aa993b 5674 /* On HP-UX if you set a h/w
c906108c
SS
5675 watchpoint before the "run" command, the inferior dies with a e.g.,
5676 SIGILL once you start it. I initially believed this was due to a
5677 bad interaction between page protection traps and the initial
5678 startup sequence by the dynamic linker.
5679
5680 However, I tried avoiding that by having HP-UX's implementation of
39f77062 5681 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
c906108c
SS
5682 yet, which forced slow watches before a "run" or "attach", and it
5683 still fails somewhere in the startup code.
5684
5685 Until I figure out what's happening, I'm disallowing watches altogether
5686 before the "run" or "attach" command. We'll tell the user they must
5687 set watches after getting the program started. */
c5aa993b 5688 if (!target_has_execution)
c906108c
SS
5689 {
5690 warning ("can't do that without a running program; try \"break main\", \"run\" first");
5691 return;
5692 }
5693#endif /* HPUXHPPA */
c5aa993b 5694
4d28f7a8
KB
5695 /* Change the type of breakpoint to an ordinary watchpoint if a hardware
5696 watchpoint could not be set. */
5697 if (!mem_cnt || target_resources_ok <= 0)
5698 bp_type = bp_watchpoint;
5699
c906108c 5700 /* Now set up the breakpoint. */
4d28f7a8 5701 b = set_raw_breakpoint (sal, bp_type);
c906108c
SS
5702 set_breakpoint_count (breakpoint_count + 1);
5703 b->number = breakpoint_count;
b5de0fa7 5704 b->disposition = disp_donttouch;
c906108c
SS
5705 b->exp = exp;
5706 b->exp_valid_block = exp_valid_block;
5707 b->exp_string = savestring (exp_start, exp_end - exp_start);
5708 b->val = val;
5709 b->cond = cond;
5710 if (cond_start)
5711 b->cond_string = savestring (cond_start, cond_end - cond_start);
5712 else
5713 b->cond_string = 0;
c5aa993b 5714
c906108c
SS
5715 frame = block_innermost_frame (exp_valid_block);
5716 if (frame)
5717 {
5718 prev_frame = get_prev_frame (frame);
7a424e99 5719 b->watchpoint_frame = get_frame_id (frame);
c906108c
SS
5720 }
5721 else
101dcfbe
AC
5722 {
5723 memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame));
5724 }
c906108c 5725
c906108c
SS
5726 /* If the expression is "local", then set up a "watchpoint scope"
5727 breakpoint at the point where we've left the scope of the watchpoint
5728 expression. */
5729 if (innermost_block)
5730 {
5731 if (prev_frame)
5732 {
5733 struct breakpoint *scope_breakpoint;
e86ae29f
KS
5734 scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame),
5735 bp_watchpoint_scope);
c906108c 5736
b5de0fa7 5737 scope_breakpoint->enable_state = bp_enabled;
c906108c
SS
5738
5739 /* Automatically delete the breakpoint when it hits. */
b5de0fa7 5740 scope_breakpoint->disposition = disp_del;
c906108c
SS
5741
5742 /* Only break in the proper frame (help with recursion). */
818dd999 5743 scope_breakpoint->frame_id = get_frame_id (prev_frame);
c906108c
SS
5744
5745 /* Set the address at which we will stop. */
5cab636d
DJ
5746 scope_breakpoint->loc->requested_address
5747 = get_frame_pc (prev_frame);
5748 scope_breakpoint->loc->address
88f7da05
KB
5749 = adjust_breakpoint_address (scope_breakpoint->loc->requested_address,
5750 scope_breakpoint->type);
c906108c
SS
5751
5752 /* The scope breakpoint is related to the watchpoint. We
5753 will need to act on them together. */
5754 b->related_breakpoint = scope_breakpoint;
5755 }
5756 }
5757 value_free_to_mark (mark);
5758 mention (b);
5759}
5760
5761/* Return count of locations need to be watched and can be handled
5762 in hardware. If the watchpoint can not be handled
5763 in hardware return zero. */
5764
53a5351d
JM
5765#if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
5766#define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
6ab3a9c9 5767 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
c906108c
SS
5768#endif
5769
5770static int
fba45db2 5771can_use_hardware_watchpoint (struct value *v)
c906108c
SS
5772{
5773 int found_memory_cnt = 0;
2e70b7b9 5774 struct value *head = v;
c906108c
SS
5775
5776 /* Did the user specifically forbid us to use hardware watchpoints? */
c5aa993b 5777 if (!can_use_hw_watchpoints)
c906108c 5778 return 0;
c5aa993b 5779
5c44784c
JM
5780 /* Make sure that the value of the expression depends only upon
5781 memory contents, and values computed from them within GDB. If we
5782 find any register references or function calls, we can't use a
5783 hardware watchpoint.
5784
5785 The idea here is that evaluating an expression generates a series
5786 of values, one holding the value of every subexpression. (The
5787 expression a*b+c has five subexpressions: a, b, a*b, c, and
5788 a*b+c.) GDB's values hold almost enough information to establish
5789 the criteria given above --- they identify memory lvalues,
5790 register lvalues, computed values, etcetera. So we can evaluate
5791 the expression, and then scan the chain of values that leaves
5792 behind to decide whether we can detect any possible change to the
5793 expression's final value using only hardware watchpoints.
5794
5795 However, I don't think that the values returned by inferior
5796 function calls are special in any way. So this function may not
5797 notice that an expression involving an inferior function call
5798 can't be watched with hardware watchpoints. FIXME. */
c5aa993b 5799 for (; v; v = v->next)
c906108c 5800 {
5c44784c 5801 if (VALUE_LVAL (v) == lval_memory)
c906108c 5802 {
5c44784c
JM
5803 if (VALUE_LAZY (v))
5804 /* A lazy memory lvalue is one that GDB never needed to fetch;
5805 we either just used its address (e.g., `a' in `a.b') or
5806 we never needed it at all (e.g., `a' in `a,b'). */
5807 ;
53a5351d 5808 else
5c44784c
JM
5809 {
5810 /* Ahh, memory we actually used! Check if we can cover
5811 it with hardware watchpoints. */
df407dfe 5812 struct type *vtype = check_typedef (value_type (v));
2e70b7b9
MS
5813
5814 /* We only watch structs and arrays if user asked for it
5815 explicitly, never if they just happen to appear in a
5816 middle of some value chain. */
5817 if (v == head
5818 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
5819 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
5820 {
df407dfe
AC
5821 CORE_ADDR vaddr = VALUE_ADDRESS (v) + value_offset (v);
5822 int len = TYPE_LENGTH (value_type (v));
2e70b7b9
MS
5823
5824 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
5825 return 0;
5826 else
5827 found_memory_cnt++;
5828 }
5c44784c 5829 }
c5aa993b 5830 }
c906108c 5831 else if (v->lval != not_lval && v->modifiable == 0)
53a5351d
JM
5832 return 0; /* ??? What does this represent? */
5833 else if (v->lval == lval_register)
5834 return 0; /* cannot watch a register with a HW watchpoint */
c906108c
SS
5835 }
5836
5837 /* The expression itself looks suitable for using a hardware
5838 watchpoint, but give the target machine a chance to reject it. */
5839 return found_memory_cnt;
5840}
5841
8b93c638 5842void
fba45db2 5843watch_command_wrapper (char *arg, int from_tty)
8b93c638
JM
5844{
5845 watch_command (arg, from_tty);
5846}
8926118c 5847
c5aa993b 5848static void
fba45db2 5849watch_command (char *arg, int from_tty)
c906108c 5850{
53a5351d 5851 watch_command_1 (arg, hw_write, from_tty);
c906108c
SS
5852}
5853
8b93c638 5854void
fba45db2 5855rwatch_command_wrapper (char *arg, int from_tty)
8b93c638
JM
5856{
5857 rwatch_command (arg, from_tty);
5858}
8926118c 5859
c5aa993b 5860static void
fba45db2 5861rwatch_command (char *arg, int from_tty)
c906108c 5862{
53a5351d 5863 watch_command_1 (arg, hw_read, from_tty);
c906108c
SS
5864}
5865
8b93c638 5866void
fba45db2 5867awatch_command_wrapper (char *arg, int from_tty)
8b93c638
JM
5868{
5869 awatch_command (arg, from_tty);
5870}
8926118c 5871
c5aa993b 5872static void
fba45db2 5873awatch_command (char *arg, int from_tty)
c906108c 5874{
53a5351d 5875 watch_command_1 (arg, hw_access, from_tty);
c906108c 5876}
c906108c 5877\f
c5aa993b 5878
43ff13b4 5879/* Helper routines for the until_command routine in infcmd.c. Here
c906108c
SS
5880 because it uses the mechanisms of breakpoints. */
5881
43ff13b4
JM
5882/* This function is called by fetch_inferior_event via the
5883 cmd_continuation pointer, to complete the until command. It takes
5884 care of cleaning up the temporary breakpoints set up by the until
5885 command. */
c2c6d25f
JM
5886static void
5887until_break_command_continuation (struct continuation_arg *arg)
43ff13b4 5888{
0d06e24b
JM
5889 struct cleanup *cleanups;
5890
57e687d9 5891 cleanups = (struct cleanup *) arg->data.pointer;
0d06e24b 5892 do_exec_cleanups (cleanups);
43ff13b4
JM
5893}
5894
c906108c 5895void
ae66c1fc 5896until_break_command (char *arg, int from_tty, int anywhere)
c906108c
SS
5897{
5898 struct symtabs_and_lines sals;
5899 struct symtab_and_line sal;
6e7f8b9c 5900 struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame);
c906108c
SS
5901 struct breakpoint *breakpoint;
5902 struct cleanup *old_chain;
0d06e24b
JM
5903 struct continuation_arg *arg1;
5904
c906108c
SS
5905
5906 clear_proceed_status ();
5907
5908 /* Set a breakpoint where the user wants it and at return from
5909 this function */
c5aa993b 5910
c906108c
SS
5911 if (default_breakpoint_valid)
5912 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
68219205 5913 default_breakpoint_line, (char ***) NULL, NULL);
c906108c 5914 else
53a5351d 5915 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL,
68219205 5916 0, (char ***) NULL, NULL);
c5aa993b 5917
c906108c
SS
5918 if (sals.nelts != 1)
5919 error ("Couldn't get information on specified line.");
c5aa993b 5920
c906108c 5921 sal = sals.sals[0];
b8c9b27d 5922 xfree (sals.sals); /* malloc'd, so freed */
c5aa993b 5923
c906108c
SS
5924 if (*arg)
5925 error ("Junk at end of arguments.");
c5aa993b 5926
c906108c 5927 resolve_sal_pc (&sal);
c5aa993b 5928
ae66c1fc
EZ
5929 if (anywhere)
5930 /* If the user told us to continue until a specified location,
5931 we don't specify a frame at which we need to stop. */
5932 breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until);
5933 else
5934 /* Otherwise, specify the current frame, because we want to stop only
5935 at the very same frame. */
5936 breakpoint = set_momentary_breakpoint (sal,
5937 get_frame_id (deprecated_selected_frame),
5938 bp_until);
c5aa993b 5939
362646f5 5940 if (!target_can_async_p ())
4d6140d9 5941 old_chain = make_cleanup_delete_breakpoint (breakpoint);
43ff13b4 5942 else
4d6140d9 5943 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
43ff13b4
JM
5944
5945 /* If we are running asynchronously, and the target supports async
5946 execution, we are not waiting for the target to stop, in the call
5947 tp proceed, below. This means that we cannot delete the
5948 brekpoints until the target has actually stopped. The only place
5949 where we get a chance to do that is in fetch_inferior_event, so
5950 we must set things up for that. */
5951
362646f5 5952 if (target_can_async_p ())
43ff13b4 5953 {
0d06e24b
JM
5954 /* In this case the arg for the continuation is just the point
5955 in the exec_cleanups chain from where to start doing
5956 cleanups, because all the continuation does is the cleanups in
5957 the exec_cleanup_chain. */
5958 arg1 =
5959 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
57e687d9
MS
5960 arg1->next = NULL;
5961 arg1->data.pointer = old_chain;
0d06e24b
JM
5962
5963 add_continuation (until_break_command_continuation, arg1);
43ff13b4 5964 }
c906108c 5965
ae66c1fc
EZ
5966 /* Keep within the current frame, or in frames called by the current
5967 one. */
c906108c
SS
5968 if (prev_frame)
5969 {
30f7db39
AC
5970 sal = find_pc_line (get_frame_pc (prev_frame), 0);
5971 sal.pc = get_frame_pc (prev_frame);
818dd999
AC
5972 breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame),
5973 bp_until);
362646f5 5974 if (!target_can_async_p ())
4d6140d9 5975 make_cleanup_delete_breakpoint (breakpoint);
43ff13b4 5976 else
4d6140d9 5977 make_exec_cleanup_delete_breakpoint (breakpoint);
c906108c 5978 }
c5aa993b 5979
c906108c 5980 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
43ff13b4
JM
5981 /* Do the cleanups now, anly if we are not running asynchronously,
5982 of if we are, but the target is still synchronous. */
362646f5 5983 if (!target_can_async_p ())
c5aa993b 5984 do_cleanups (old_chain);
c906108c 5985}
ae66c1fc 5986
c906108c 5987static void
fba45db2 5988ep_skip_leading_whitespace (char **s)
c906108c 5989{
c5aa993b
JM
5990 if ((s == NULL) || (*s == NULL))
5991 return;
5992 while (isspace (**s))
5993 *s += 1;
c906108c 5994}
c5aa993b 5995
c906108c
SS
5996/* This function examines a string, and attempts to find a token
5997 that might be an event name in the leading characters. If a
5998 possible match is found, a pointer to the last character of
5999 the token is returned. Else, NULL is returned. */
53a5351d 6000
c906108c 6001static char *
fba45db2 6002ep_find_event_name_end (char *arg)
c906108c 6003{
c5aa993b
JM
6004 char *s = arg;
6005 char *event_name_end = NULL;
6006
c906108c
SS
6007 /* If we could depend upon the presense of strrpbrk, we'd use that... */
6008 if (arg == NULL)
6009 return NULL;
c5aa993b 6010
c906108c 6011 /* We break out of the loop when we find a token delimiter.
c5aa993b
JM
6012 Basically, we're looking for alphanumerics and underscores;
6013 anything else delimites the token. */
c906108c
SS
6014 while (*s != '\0')
6015 {
c5aa993b
JM
6016 if (!isalnum (*s) && (*s != '_'))
6017 break;
c906108c
SS
6018 event_name_end = s;
6019 s++;
6020 }
c5aa993b 6021
c906108c
SS
6022 return event_name_end;
6023}
6024
c5aa993b 6025
c906108c
SS
6026/* This function attempts to parse an optional "if <cond>" clause
6027 from the arg string. If one is not found, it returns NULL.
c5aa993b 6028
c906108c
SS
6029 Else, it returns a pointer to the condition string. (It does not
6030 attempt to evaluate the string against a particular block.) And,
6031 it updates arg to point to the first character following the parsed
6032 if clause in the arg string. */
53a5351d 6033
c906108c 6034static char *
fba45db2 6035ep_parse_optional_if_clause (char **arg)
c906108c 6036{
c5aa993b
JM
6037 char *cond_string;
6038
6039 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
c906108c 6040 return NULL;
c5aa993b 6041
c906108c
SS
6042 /* Skip the "if" keyword. */
6043 (*arg) += 2;
c5aa993b 6044
c906108c
SS
6045 /* Skip any extra leading whitespace, and record the start of the
6046 condition string. */
6047 ep_skip_leading_whitespace (arg);
6048 cond_string = *arg;
c5aa993b 6049
c906108c
SS
6050 /* Assume that the condition occupies the remainder of the arg string. */
6051 (*arg) += strlen (cond_string);
c5aa993b 6052
c906108c
SS
6053 return cond_string;
6054}
c5aa993b 6055
c906108c
SS
6056/* This function attempts to parse an optional filename from the arg
6057 string. If one is not found, it returns NULL.
c5aa993b 6058
c906108c
SS
6059 Else, it returns a pointer to the parsed filename. (This function
6060 makes no attempt to verify that a file of that name exists, or is
6061 accessible.) And, it updates arg to point to the first character
6062 following the parsed filename in the arg string.
c5aa993b 6063
c906108c
SS
6064 Note that clients needing to preserve the returned filename for
6065 future access should copy it to their own buffers. */
6066static char *
fba45db2 6067ep_parse_optional_filename (char **arg)
c906108c 6068{
c5aa993b
JM
6069 static char filename[1024];
6070 char *arg_p = *arg;
6071 int i;
6072 char c;
6073
c906108c
SS
6074 if ((*arg_p == '\0') || isspace (*arg_p))
6075 return NULL;
c5aa993b
JM
6076
6077 for (i = 0;; i++)
c906108c
SS
6078 {
6079 c = *arg_p;
6080 if (isspace (c))
c5aa993b 6081 c = '\0';
c906108c
SS
6082 filename[i] = c;
6083 if (c == '\0')
c5aa993b 6084 break;
c906108c
SS
6085 arg_p++;
6086 }
6087 *arg = arg_p;
c5aa993b 6088
c906108c
SS
6089 return filename;
6090}
c5aa993b 6091
c906108c
SS
6092/* Commands to deal with catching events, such as signals, exceptions,
6093 process start/exit, etc. */
c5aa993b
JM
6094
6095typedef enum
6096{
6097 catch_fork, catch_vfork
6098}
6099catch_fork_kind;
6100
c906108c 6101static void
fba45db2
KB
6102catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag,
6103 int from_tty)
c906108c 6104{
c5aa993b
JM
6105 char *cond_string = NULL;
6106
c906108c 6107 ep_skip_leading_whitespace (&arg);
c5aa993b 6108
c906108c 6109 /* The allowed syntax is:
c5aa993b
JM
6110 catch [v]fork
6111 catch [v]fork if <cond>
6112
c906108c
SS
6113 First, check if there's an if clause. */
6114 cond_string = ep_parse_optional_if_clause (&arg);
c5aa993b 6115
c906108c
SS
6116 if ((*arg != '\0') && !isspace (*arg))
6117 error ("Junk at end of arguments.");
c5aa993b 6118
c906108c
SS
6119 /* If this target supports it, create a fork or vfork catchpoint
6120 and enable reporting of such events. */
c5aa993b
JM
6121 switch (fork_kind)
6122 {
6123 case catch_fork:
c906108c
SS
6124 create_fork_event_catchpoint (tempflag, cond_string);
6125 break;
c5aa993b 6126 case catch_vfork:
c906108c
SS
6127 create_vfork_event_catchpoint (tempflag, cond_string);
6128 break;
c5aa993b 6129 default:
c906108c
SS
6130 error ("unsupported or unknown fork kind; cannot catch it");
6131 break;
c5aa993b 6132 }
c906108c
SS
6133}
6134
6135static void
fba45db2 6136catch_exec_command_1 (char *arg, int tempflag, int from_tty)
c906108c 6137{
c5aa993b 6138 char *cond_string = NULL;
c906108c
SS
6139
6140 ep_skip_leading_whitespace (&arg);
6141
6142 /* The allowed syntax is:
c5aa993b
JM
6143 catch exec
6144 catch exec if <cond>
c906108c
SS
6145
6146 First, check if there's an if clause. */
6147 cond_string = ep_parse_optional_if_clause (&arg);
6148
6149 if ((*arg != '\0') && !isspace (*arg))
6150 error ("Junk at end of arguments.");
6151
6152 /* If this target supports it, create an exec catchpoint
6153 and enable reporting of such events. */
6154 create_exec_event_catchpoint (tempflag, cond_string);
6155}
c5aa993b 6156
c906108c 6157static void
fba45db2 6158catch_load_command_1 (char *arg, int tempflag, int from_tty)
c906108c 6159{
c5aa993b
JM
6160 char *dll_pathname = NULL;
6161 char *cond_string = NULL;
6162
c906108c 6163 ep_skip_leading_whitespace (&arg);
c5aa993b 6164
c906108c 6165 /* The allowed syntax is:
c5aa993b
JM
6166 catch load
6167 catch load if <cond>
6168 catch load <filename>
6169 catch load <filename> if <cond>
6170
c906108c
SS
6171 The user is not allowed to specify the <filename> after an
6172 if clause.
c5aa993b 6173
c906108c 6174 We'll ignore the pathological case of a file named "if".
c5aa993b 6175
c906108c
SS
6176 First, check if there's an if clause. If so, then there
6177 cannot be a filename. */
6178 cond_string = ep_parse_optional_if_clause (&arg);
c5aa993b 6179
c906108c
SS
6180 /* If there was an if clause, then there cannot be a filename.
6181 Else, there might be a filename and an if clause. */
6182 if (cond_string == NULL)
6183 {
6184 dll_pathname = ep_parse_optional_filename (&arg);
6185 ep_skip_leading_whitespace (&arg);
6186 cond_string = ep_parse_optional_if_clause (&arg);
6187 }
c5aa993b 6188
c906108c
SS
6189 if ((*arg != '\0') && !isspace (*arg))
6190 error ("Junk at end of arguments.");
c5aa993b 6191
c906108c
SS
6192 /* Create a load breakpoint that only triggers when a load of
6193 the specified dll (or any dll, if no pathname was specified)
6194 occurs. */
39f77062 6195 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag,
53a5351d 6196 dll_pathname, cond_string);
c906108c 6197}
c5aa993b 6198
c906108c 6199static void
fba45db2 6200catch_unload_command_1 (char *arg, int tempflag, int from_tty)
c906108c 6201{
c5aa993b
JM
6202 char *dll_pathname = NULL;
6203 char *cond_string = NULL;
6204
c906108c 6205 ep_skip_leading_whitespace (&arg);
c5aa993b 6206
c906108c 6207 /* The allowed syntax is:
c5aa993b
JM
6208 catch unload
6209 catch unload if <cond>
6210 catch unload <filename>
6211 catch unload <filename> if <cond>
6212
c906108c
SS
6213 The user is not allowed to specify the <filename> after an
6214 if clause.
c5aa993b 6215
c906108c 6216 We'll ignore the pathological case of a file named "if".
c5aa993b 6217
c906108c
SS
6218 First, check if there's an if clause. If so, then there
6219 cannot be a filename. */
6220 cond_string = ep_parse_optional_if_clause (&arg);
c5aa993b 6221
c906108c
SS
6222 /* If there was an if clause, then there cannot be a filename.
6223 Else, there might be a filename and an if clause. */
6224 if (cond_string == NULL)
6225 {
6226 dll_pathname = ep_parse_optional_filename (&arg);
6227 ep_skip_leading_whitespace (&arg);
6228 cond_string = ep_parse_optional_if_clause (&arg);
6229 }
c5aa993b 6230
c906108c
SS
6231 if ((*arg != '\0') && !isspace (*arg))
6232 error ("Junk at end of arguments.");
c5aa993b 6233
c906108c
SS
6234 /* Create an unload breakpoint that only triggers when an unload of
6235 the specified dll (or any dll, if no pathname was specified)
6236 occurs. */
39f77062 6237 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag,
53a5351d 6238 dll_pathname, cond_string);
c906108c 6239}
c906108c
SS
6240
6241/* Commands to deal with catching exceptions. */
6242
6243/* Set a breakpoint at the specified callback routine for an
c5aa993b 6244 exception event callback */
c906108c
SS
6245
6246static void
fba45db2
KB
6247create_exception_catchpoint (int tempflag, char *cond_string,
6248 enum exception_event_kind ex_event,
6249 struct symtab_and_line *sal)
c906108c 6250{
c5aa993b 6251 struct breakpoint *b;
c5aa993b 6252 int thread = -1; /* All threads. */
4d28f7a8 6253 enum bptype bptype;
c906108c 6254
c5aa993b 6255 if (!sal) /* no exception support? */
c906108c
SS
6256 return;
6257
c906108c
SS
6258 switch (ex_event)
6259 {
c5aa993b 6260 case EX_EVENT_THROW:
4d28f7a8 6261 bptype = bp_catch_throw;
c5aa993b
JM
6262 break;
6263 case EX_EVENT_CATCH:
4d28f7a8 6264 bptype = bp_catch_catch;
c5aa993b
JM
6265 break;
6266 default: /* error condition */
c5aa993b 6267 error ("Internal error -- invalid catchpoint kind");
c906108c 6268 }
4d28f7a8
KB
6269
6270 b = set_raw_breakpoint (*sal, bptype);
6271 set_breakpoint_count (breakpoint_count + 1);
6272 b->number = breakpoint_count;
6273 b->cond = NULL;
6274 b->cond_string = (cond_string == NULL) ?
6275 NULL : savestring (cond_string, strlen (cond_string));
6276 b->thread = thread;
6277 b->addr_string = NULL;
b5de0fa7
EZ
6278 b->enable_state = bp_enabled;
6279 b->disposition = tempflag ? disp_del : disp_donttouch;
c906108c
SS
6280 mention (b);
6281}
6282
3086aeae
DJ
6283static enum print_stop_action
6284print_exception_catchpoint (struct breakpoint *b)
6285{
6286 annotate_catchpoint (b->number);
6287
6288 if (strstr (b->addr_string, "throw") != NULL)
6289 printf_filtered ("\nCatchpoint %d (exception thrown)\n",
6290 b->number);
6291 else
6292 printf_filtered ("\nCatchpoint %d (exception caught)\n",
6293 b->number);
6294
6295 return PRINT_SRC_AND_LOC;
6296}
6297
6298static void
6299print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr)
6300{
6301 if (addressprint)
6302 {
6303 annotate_field (4);
5cab636d 6304 ui_out_field_core_addr (uiout, "addr", b->loc->address);
3086aeae
DJ
6305 }
6306 annotate_field (5);
5cab636d 6307 *last_addr = b->loc->address;
3086aeae
DJ
6308 if (strstr (b->addr_string, "throw") != NULL)
6309 ui_out_field_string (uiout, "what", "exception throw");
6310 else
6311 ui_out_field_string (uiout, "what", "exception catch");
6312}
6313
6314static void
6315print_mention_exception_catchpoint (struct breakpoint *b)
6316{
6317 if (strstr (b->addr_string, "throw") != NULL)
6318 printf_filtered ("Catchpoint %d (throw)", b->number);
6319 else
6320 printf_filtered ("Catchpoint %d (catch)", b->number);
6321}
6322
6323static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = {
6324 print_exception_catchpoint,
6325 print_one_exception_catchpoint,
6326 print_mention_exception_catchpoint
6327};
6328
6329static int
6330handle_gnu_v3_exceptions (int tempflag, char *cond_string,
6331 enum exception_event_kind ex_event, int from_tty)
6332{
6333 char *trigger_func_name, *nameptr;
6334 struct symtabs_and_lines sals;
6335 struct breakpoint *b;
6336
6337 if (ex_event == EX_EVENT_CATCH)
6338 trigger_func_name = xstrdup ("__cxa_begin_catch");
6339 else
6340 trigger_func_name = xstrdup ("__cxa_throw");
6341
6342 nameptr = trigger_func_name;
68219205 6343 sals = decode_line_1 (&nameptr, 1, NULL, 0, NULL, NULL);
3086aeae
DJ
6344 if (sals.nelts == 0)
6345 {
b59661bd 6346 xfree (trigger_func_name);
3086aeae
DJ
6347 return 0;
6348 }
6349
6350 b = set_raw_breakpoint (sals.sals[0], bp_breakpoint);
6351 set_breakpoint_count (breakpoint_count + 1);
6352 b->number = breakpoint_count;
6353 b->cond = NULL;
6354 b->cond_string = (cond_string == NULL) ?
6355 NULL : savestring (cond_string, strlen (cond_string));
6356 b->thread = -1;
6357 b->addr_string = trigger_func_name;
6358 b->enable_state = bp_enabled;
6359 b->disposition = tempflag ? disp_del : disp_donttouch;
6360 b->ops = &gnu_v3_exception_catchpoint_ops;
6361
b59661bd 6362 xfree (sals.sals);
3086aeae
DJ
6363 mention (b);
6364 return 1;
6365}
6366
c5aa993b 6367/* Deal with "catch catch" and "catch throw" commands */
c906108c
SS
6368
6369static void
fba45db2
KB
6370catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
6371 int tempflag, int from_tty)
c906108c 6372{
c5aa993b
JM
6373 char *cond_string = NULL;
6374 struct symtab_and_line *sal = NULL;
6375
c906108c 6376 ep_skip_leading_whitespace (&arg);
c5aa993b 6377
c906108c
SS
6378 cond_string = ep_parse_optional_if_clause (&arg);
6379
6380 if ((*arg != '\0') && !isspace (*arg))
6381 error ("Junk at end of arguments.");
6382
6383 if ((ex_event != EX_EVENT_THROW) &&
6384 (ex_event != EX_EVENT_CATCH))
6385 error ("Unsupported or unknown exception event; cannot catch it");
6386
3086aeae
DJ
6387 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty))
6388 return;
6389
c906108c
SS
6390 /* See if we can find a callback routine */
6391 sal = target_enable_exception_callback (ex_event, 1);
6392
c5aa993b 6393 if (sal)
c906108c
SS
6394 {
6395 /* We have callbacks from the runtime system for exceptions.
c5aa993b 6396 Set a breakpoint on the sal found, if no errors */
c906108c 6397 if (sal != (struct symtab_and_line *) -1)
c5aa993b 6398 create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
c906108c 6399 else
53a5351d 6400 return; /* something went wrong with setting up callbacks */
c906108c 6401 }
c5aa993b 6402
69f567ae 6403 warning ("Unsupported with this platform/compiler combination.");
c906108c
SS
6404}
6405
6406/* Cover routine to allow wrapping target_enable_exception_catchpoints
6407 inside a catch_errors */
6408
6409static int
4efb68b1 6410cover_target_enable_exception_callback (void *arg)
c906108c
SS
6411{
6412 args_for_catchpoint_enable *args = arg;
6413 struct symtab_and_line *sal;
b5de0fa7 6414 sal = target_enable_exception_callback (args->kind, args->enable_p);
c906108c
SS
6415 if (sal == NULL)
6416 return 0;
6417 else if (sal == (struct symtab_and_line *) -1)
6418 return -1;
6419 else
c5aa993b 6420 return 1; /*is valid */
c906108c
SS
6421}
6422
c906108c 6423static void
fba45db2 6424catch_command_1 (char *arg, int tempflag, int from_tty)
c906108c 6425{
c5aa993b 6426
c906108c
SS
6427 /* The first argument may be an event name, such as "start" or "load".
6428 If so, then handle it as such. If it doesn't match an event name,
6429 then attempt to interpret it as an exception name. (This latter is
6430 the v4.16-and-earlier GDB meaning of the "catch" command.)
c5aa993b 6431
c906108c 6432 First, try to find the bounds of what might be an event name. */
c5aa993b
JM
6433 char *arg1_start = arg;
6434 char *arg1_end;
6435 int arg1_length;
6436
c906108c
SS
6437 if (arg1_start == NULL)
6438 {
c5aa993b 6439 /* Old behaviour was to use pre-v-4.16 syntax */
c906108c
SS
6440 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
6441 /* return; */
c5aa993b 6442 /* Now, this is not allowed */
c906108c
SS
6443 error ("Catch requires an event name.");
6444
6445 }
6446 arg1_end = ep_find_event_name_end (arg1_start);
6447 if (arg1_end == NULL)
6448 error ("catch requires an event");
6449 arg1_length = arg1_end + 1 - arg1_start;
c5aa993b 6450
c906108c
SS
6451 /* Try to match what we found against known event names. */
6452 if (strncmp (arg1_start, "signal", arg1_length) == 0)
6453 {
6454 error ("Catch of signal not yet implemented");
6455 }
6456 else if (strncmp (arg1_start, "catch", arg1_length) == 0)
6457 {
53a5351d
JM
6458 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1,
6459 tempflag, from_tty);
c906108c
SS
6460 }
6461 else if (strncmp (arg1_start, "throw", arg1_length) == 0)
6462 {
53a5351d
JM
6463 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1,
6464 tempflag, from_tty);
c906108c
SS
6465 }
6466 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
6467 {
6468 error ("Catch of thread_start not yet implemented");
6469 }
6470 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
6471 {
6472 error ("Catch of thread_exit not yet implemented");
6473 }
6474 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
6475 {
6476 error ("Catch of thread_join not yet implemented");
6477 }
6478 else if (strncmp (arg1_start, "start", arg1_length) == 0)
6479 {
6480 error ("Catch of start not yet implemented");
6481 }
6482 else if (strncmp (arg1_start, "exit", arg1_length) == 0)
6483 {
6484 error ("Catch of exit not yet implemented");
6485 }
6486 else if (strncmp (arg1_start, "fork", arg1_length) == 0)
6487 {
c5aa993b 6488 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
c906108c
SS
6489 }
6490 else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
6491 {
c5aa993b 6492 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
c906108c
SS
6493 }
6494 else if (strncmp (arg1_start, "exec", arg1_length) == 0)
6495 {
c5aa993b 6496 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
c906108c
SS
6497 }
6498 else if (strncmp (arg1_start, "load", arg1_length) == 0)
6499 {
c5aa993b 6500 catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
c906108c
SS
6501 }
6502 else if (strncmp (arg1_start, "unload", arg1_length) == 0)
6503 {
c5aa993b 6504 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
c906108c
SS
6505 }
6506 else if (strncmp (arg1_start, "stop", arg1_length) == 0)
6507 {
6508 error ("Catch of stop not yet implemented");
6509 }
c5aa993b 6510
c906108c
SS
6511 /* This doesn't appear to be an event name */
6512
6513 else
6514 {
6515 /* Pre-v.4.16 behaviour was to treat the argument
c5aa993b 6516 as the name of an exception */
c906108c 6517 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
c5aa993b 6518 /* Now this is not allowed */
c906108c
SS
6519 error ("Unknown event kind specified for catch");
6520
6521 }
6522}
6523
6524/* Used by the gui, could be made a worker for other things. */
6525
6526struct breakpoint *
fba45db2 6527set_breakpoint_sal (struct symtab_and_line sal)
c906108c
SS
6528{
6529 struct breakpoint *b;
4d28f7a8 6530 b = set_raw_breakpoint (sal, bp_breakpoint);
c906108c
SS
6531 set_breakpoint_count (breakpoint_count + 1);
6532 b->number = breakpoint_count;
c906108c
SS
6533 b->cond = 0;
6534 b->thread = -1;
6535 return b;
6536}
6537
c906108c 6538static void
fba45db2 6539catch_command (char *arg, int from_tty)
c906108c
SS
6540{
6541 catch_command_1 (arg, 0, from_tty);
6542}
6543\f
6544
6545static void
fba45db2 6546tcatch_command (char *arg, int from_tty)
c906108c
SS
6547{
6548 catch_command_1 (arg, 1, from_tty);
6549}
6550
80f8a6eb 6551/* Delete breakpoints by address or line. */
c906108c
SS
6552
6553static void
fba45db2 6554clear_command (char *arg, int from_tty)
c906108c 6555{
80f8a6eb 6556 struct breakpoint *b, *tmp, *prev, *found;
c906108c
SS
6557 int default_match;
6558 struct symtabs_and_lines sals;
6559 struct symtab_and_line sal;
c906108c
SS
6560 int i;
6561
6562 if (arg)
6563 {
6564 sals = decode_line_spec (arg, 1);
6565 default_match = 0;
6566 }
6567 else
6568 {
c5aa993b 6569 sals.sals = (struct symtab_and_line *)
c906108c 6570 xmalloc (sizeof (struct symtab_and_line));
80f8a6eb 6571 make_cleanup (xfree, sals.sals);
fe39c653 6572 init_sal (&sal); /* initialize to zeroes */
c906108c
SS
6573 sal.line = default_breakpoint_line;
6574 sal.symtab = default_breakpoint_symtab;
6575 sal.pc = default_breakpoint_address;
6576 if (sal.symtab == 0)
6577 error ("No source file specified.");
6578
6579 sals.sals[0] = sal;
6580 sals.nelts = 1;
6581
6582 default_match = 1;
6583 }
6584
6585 /* For each line spec given, delete bps which correspond
80f8a6eb
MS
6586 to it. Do it in two passes, solely to preserve the current
6587 behavior that from_tty is forced true if we delete more than
6588 one breakpoint. */
c906108c 6589
80f8a6eb 6590 found = NULL;
c906108c
SS
6591 for (i = 0; i < sals.nelts; i++)
6592 {
6593 /* If exact pc given, clear bpts at that pc.
c5aa993b
JM
6594 If line given (pc == 0), clear all bpts on specified line.
6595 If defaulting, clear all bpts on default line
c906108c 6596 or at default pc.
c5aa993b
JM
6597
6598 defaulting sal.pc != 0 tests to do
6599
6600 0 1 pc
6601 1 1 pc _and_ line
6602 0 0 line
6603 1 0 <can't happen> */
c906108c
SS
6604
6605 sal = sals.sals[i];
80f8a6eb 6606 prev = NULL;
c906108c 6607
80f8a6eb
MS
6608 /* Find all matching breakpoints, remove them from the
6609 breakpoint chain, and add them to the 'found' chain. */
6610 ALL_BREAKPOINTS_SAFE (b, tmp)
c5aa993b 6611 {
80f8a6eb
MS
6612 /* Are we going to delete b? */
6613 if (b->type != bp_none
6614 && b->type != bp_watchpoint
6615 && b->type != bp_hardware_watchpoint
6616 && b->type != bp_read_watchpoint
6617 && b->type != bp_access_watchpoint
6618 /* Not if b is a watchpoint of any sort... */
5cab636d 6619 && (((sal.pc && (b->loc->address == sal.pc))
cf3a9e5b
DJ
6620 && (!section_is_overlay (b->loc->section)
6621 || b->loc->section == sal.section))
80f8a6eb
MS
6622 /* Yes, if sal.pc matches b (modulo overlays). */
6623 || ((default_match || (0 == sal.pc))
6624 && b->source_file != NULL
6625 && sal.symtab != NULL
6314a349 6626 && strcmp (b->source_file, sal.symtab->filename) == 0
80f8a6eb
MS
6627 && b->line_number == sal.line)))
6628 /* Yes, if sal source file and line matches b. */
6629 {
6630 /* Remove it from breakpoint_chain... */
6631 if (b == breakpoint_chain)
6632 {
6633 /* b is at the head of the list */
6634 breakpoint_chain = b->next;
6635 }
6636 else
6637 {
6638 prev->next = b->next;
6639 }
6640 /* And add it to 'found' chain. */
6641 b->next = found;
6642 found = b;
6643 }
c906108c 6644 else
80f8a6eb
MS
6645 {
6646 /* Keep b, and keep a pointer to it. */
6647 prev = b;
6648 }
c906108c 6649 }
80f8a6eb
MS
6650 }
6651 /* Now go thru the 'found' chain and delete them. */
6652 if (found == 0)
6653 {
6654 if (arg)
6655 error ("No breakpoint at %s.", arg);
6656 else
6657 error ("No breakpoint at this line.");
6658 }
c906108c 6659
80f8a6eb
MS
6660 if (found->next)
6661 from_tty = 1; /* Always report if deleted more than one */
6662 if (from_tty)
6663 printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
6664 breakpoints_changed ();
6665 while (found)
6666 {
c5aa993b 6667 if (from_tty)
80f8a6eb
MS
6668 printf_unfiltered ("%d ", found->number);
6669 tmp = found->next;
6670 delete_breakpoint (found);
6671 found = tmp;
c906108c 6672 }
80f8a6eb
MS
6673 if (from_tty)
6674 putchar_unfiltered ('\n');
c906108c
SS
6675}
6676\f
6677/* Delete breakpoint in BS if they are `delete' breakpoints and
6678 all breakpoints that are marked for deletion, whether hit or not.
6679 This is called after any breakpoint is hit, or after errors. */
6680
6681void
fba45db2 6682breakpoint_auto_delete (bpstat bs)
c906108c
SS
6683{
6684 struct breakpoint *b, *temp;
6685
6686 for (; bs; bs = bs->next)
b5de0fa7 6687 if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
c906108c
SS
6688 && bs->stop)
6689 delete_breakpoint (bs->breakpoint_at);
6690
6691 ALL_BREAKPOINTS_SAFE (b, temp)
c5aa993b 6692 {
b5de0fa7 6693 if (b->disposition == disp_del_at_next_stop)
c5aa993b
JM
6694 delete_breakpoint (b);
6695 }
c906108c
SS
6696}
6697
53a5351d
JM
6698/* Delete a breakpoint and clean up all traces of it in the data
6699 structures. */
c906108c
SS
6700
6701void
fba45db2 6702delete_breakpoint (struct breakpoint *bpt)
c906108c 6703{
52f0bd74
AC
6704 struct breakpoint *b;
6705 bpstat bs;
7cc221ef 6706 struct bp_location *loc;
c906108c
SS
6707
6708 if (bpt == NULL)
6709 error ("Internal error (attempted to delete a NULL breakpoint)");
6710
6711
6712 /* Has this bp already been deleted? This can happen because multiple
6713 lists can hold pointers to bp's. bpstat lists are especial culprits.
6714
6715 One example of this happening is a watchpoint's scope bp. When the
6716 scope bp triggers, we notice that the watchpoint is out of scope, and
6717 delete it. We also delete its scope bp. But the scope bp is marked
6718 "auto-deleting", and is already on a bpstat. That bpstat is then
6719 checked for auto-deleting bp's, which are deleted.
6720
6721 A real solution to this problem might involve reference counts in bp's,
6722 and/or giving them pointers back to their referencing bpstat's, and
6723 teaching delete_breakpoint to only free a bp's storage when no more
1272ad14 6724 references were extent. A cheaper bandaid was chosen. */
c906108c
SS
6725 if (bpt->type == bp_none)
6726 return;
6727
9a4105ab
AC
6728 if (deprecated_delete_breakpoint_hook)
6729 deprecated_delete_breakpoint_hook (bpt);
104c1213 6730 breakpoint_delete_event (bpt->number);
c906108c 6731
5cab636d 6732 if (bpt->loc->inserted)
0bde7532 6733 remove_breakpoint (bpt->loc, mark_inserted);
c5aa993b 6734
7270d8f2
OF
6735 free_valchain (bpt->loc);
6736
c906108c
SS
6737 if (breakpoint_chain == bpt)
6738 breakpoint_chain = bpt->next;
6739
7cc221ef
DJ
6740 if (bp_location_chain == bpt->loc)
6741 bp_location_chain = bpt->loc->next;
6742
c906108c
SS
6743 /* If we have callback-style exception catchpoints, don't go through
6744 the adjustments to the C++ runtime library etc. if the inferior
6745 isn't actually running. target_enable_exception_callback for a
6746 null target ops vector gives an undesirable error message, so we
6747 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
1272ad14 6748 exceptions are supported in this way, it's OK for now. FIXME */
c906108c
SS
6749 if (ep_is_exception_catchpoint (bpt) && target_has_execution)
6750 {
53a5351d 6751 /* Format possible error msg */
9ebf4acf
AC
6752 char *message = xstrprintf ("Error in deleting catchpoint %d:\n",
6753 bpt->number);
6754 struct cleanup *cleanups = make_cleanup (xfree, message);
6755 args_for_catchpoint_enable args;
53a5351d
JM
6756 args.kind = bpt->type == bp_catch_catch ?
6757 EX_EVENT_CATCH : EX_EVENT_THROW;
b5de0fa7 6758 args.enable_p = 0;
c906108c
SS
6759 catch_errors (cover_target_enable_exception_callback, &args,
6760 message, RETURN_MASK_ALL);
9ebf4acf 6761 do_cleanups (cleanups);
c906108c
SS
6762 }
6763
6764
6765 ALL_BREAKPOINTS (b)
6766 if (b->next == bpt)
c5aa993b
JM
6767 {
6768 b->next = bpt->next;
6769 break;
6770 }
c906108c 6771
7cc221ef
DJ
6772 ALL_BP_LOCATIONS (loc)
6773 if (loc->next == bpt->loc)
6774 {
6775 loc->next = bpt->loc->next;
6776 break;
6777 }
6778
9f60f21b 6779 check_duplicates (bpt);
c906108c
SS
6780 /* If this breakpoint was inserted, and there is another breakpoint
6781 at the same address, we need to insert the other breakpoint. */
5cab636d 6782 if (bpt->loc->inserted
c906108c
SS
6783 && bpt->type != bp_hardware_watchpoint
6784 && bpt->type != bp_read_watchpoint
6785 && bpt->type != bp_access_watchpoint
6786 && bpt->type != bp_catch_fork
6787 && bpt->type != bp_catch_vfork
6788 && bpt->type != bp_catch_exec)
6789 {
6790 ALL_BREAKPOINTS (b)
5cab636d 6791 if (b->loc->address == bpt->loc->address
cf3a9e5b 6792 && b->loc->section == bpt->loc->section
5cab636d 6793 && !b->loc->duplicate
b5de0fa7
EZ
6794 && b->enable_state != bp_disabled
6795 && b->enable_state != bp_shlib_disabled
0101ce28 6796 && !b->pending
b5de0fa7 6797 && b->enable_state != bp_call_disabled)
c5aa993b
JM
6798 {
6799 int val;
53a5351d 6800
c2c6d25f
JM
6801 /* We should never reach this point if there is a permanent
6802 breakpoint at the same address as the one being deleted.
6803 If there is a permanent breakpoint somewhere, it should
6804 always be the only one inserted. */
b5de0fa7 6805 if (b->enable_state == bp_permanent)
8e65ff28
AC
6806 internal_error (__FILE__, __LINE__,
6807 "another breakpoint was inserted on top of "
c2c6d25f
JM
6808 "a permanent breakpoint");
6809
53a5351d 6810 if (b->type == bp_hardware_breakpoint)
5cab636d 6811 val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents);
53a5351d 6812 else
5cab636d 6813 val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents);
53a5351d 6814
81d0cc19 6815 /* If there was an error in the insert, print a message, then stop execution. */
c5aa993b
JM
6816 if (val != 0)
6817 {
81d0cc19
GS
6818 struct ui_file *tmp_error_stream = mem_fileopen ();
6819 make_cleanup_ui_file_delete (tmp_error_stream);
6820
6821
6822 if (b->type == bp_hardware_breakpoint)
6823 {
6824 fprintf_unfiltered (tmp_error_stream,
6825 "Cannot insert hardware breakpoint %d.\n"
6826 "You may have requested too many hardware breakpoints.\n",
6827 b->number);
6828 }
6829 else
6830 {
6831 fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number);
6832 fprintf_filtered (tmp_error_stream, "Error accessing memory address ");
5cab636d 6833 print_address_numeric (b->loc->address, 1, tmp_error_stream);
81d0cc19
GS
6834 fprintf_filtered (tmp_error_stream, ": %s.\n",
6835 safe_strerror (val));
6836 }
6837
6838 fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process.");
c5aa993b 6839 target_terminal_ours_for_output ();
81d0cc19 6840 error_stream(tmp_error_stream);
c5aa993b
JM
6841 }
6842 else
5cab636d 6843 b->loc->inserted = 1;
c5aa993b 6844 }
c906108c
SS
6845 }
6846
6847 free_command_lines (&bpt->commands);
6848 if (bpt->cond)
b8c9b27d 6849 xfree (bpt->cond);
c906108c 6850 if (bpt->cond_string != NULL)
b8c9b27d 6851 xfree (bpt->cond_string);
c906108c 6852 if (bpt->addr_string != NULL)
b8c9b27d 6853 xfree (bpt->addr_string);
c906108c 6854 if (bpt->exp != NULL)
b8c9b27d 6855 xfree (bpt->exp);
c906108c 6856 if (bpt->exp_string != NULL)
b8c9b27d 6857 xfree (bpt->exp_string);
c906108c
SS
6858 if (bpt->val != NULL)
6859 value_free (bpt->val);
6860 if (bpt->source_file != NULL)
b8c9b27d 6861 xfree (bpt->source_file);
c906108c 6862 if (bpt->dll_pathname != NULL)
b8c9b27d 6863 xfree (bpt->dll_pathname);
c906108c 6864 if (bpt->triggered_dll_pathname != NULL)
b8c9b27d 6865 xfree (bpt->triggered_dll_pathname);
c906108c 6866 if (bpt->exec_pathname != NULL)
b8c9b27d 6867 xfree (bpt->exec_pathname);
c906108c
SS
6868
6869 /* Be sure no bpstat's are pointing at it after it's been freed. */
6870 /* FIXME, how can we find all bpstat's?
6871 We just check stop_bpstat for now. */
6872 for (bs = stop_bpstat; bs; bs = bs->next)
6873 if (bs->breakpoint_at == bpt)
6874 {
6875 bs->breakpoint_at = NULL;
c906108c 6876 bs->old_val = NULL;
c2b8ed2c 6877 /* bs->commands will be freed later. */
c906108c
SS
6878 }
6879 /* On the chance that someone will soon try again to delete this same
6880 bp, we mark it as deleted before freeing its storage. */
6881 bpt->type = bp_none;
6882
5cab636d 6883 xfree (bpt->loc);
b8c9b27d 6884 xfree (bpt);
c906108c
SS
6885}
6886
4d6140d9
AC
6887static void
6888do_delete_breakpoint_cleanup (void *b)
6889{
6890 delete_breakpoint (b);
6891}
6892
6893struct cleanup *
6894make_cleanup_delete_breakpoint (struct breakpoint *b)
6895{
6896 return make_cleanup (do_delete_breakpoint_cleanup, b);
6897}
6898
6899struct cleanup *
6900make_exec_cleanup_delete_breakpoint (struct breakpoint *b)
6901{
6902 return make_exec_cleanup (do_delete_breakpoint_cleanup, b);
6903}
6904
c906108c 6905void
fba45db2 6906delete_command (char *arg, int from_tty)
c906108c
SS
6907{
6908 struct breakpoint *b, *temp;
6909
ea9365bb
TT
6910 dont_repeat ();
6911
c906108c
SS
6912 if (arg == 0)
6913 {
6914 int breaks_to_delete = 0;
6915
6916 /* Delete all breakpoints if no argument.
c5aa993b
JM
6917 Do not delete internal or call-dummy breakpoints, these
6918 have to be deleted with an explicit breakpoint number argument. */
6919 ALL_BREAKPOINTS (b)
6920 {
6921 if (b->type != bp_call_dummy &&
6922 b->type != bp_shlib_event &&
c4093a6a 6923 b->type != bp_thread_event &&
1900040c 6924 b->type != bp_overlay_event &&
c5aa993b
JM
6925 b->number >= 0)
6926 breaks_to_delete = 1;
6927 }
c906108c
SS
6928
6929 /* Ask user only if there are some breakpoints to delete. */
6930 if (!from_tty
6931 || (breaks_to_delete && query ("Delete all breakpoints? ")))
6932 {
c5aa993b
JM
6933 ALL_BREAKPOINTS_SAFE (b, temp)
6934 {
6935 if (b->type != bp_call_dummy &&
6936 b->type != bp_shlib_event &&
c4093a6a 6937 b->type != bp_thread_event &&
1900040c 6938 b->type != bp_overlay_event &&
c5aa993b
JM
6939 b->number >= 0)
6940 delete_breakpoint (b);
6941 }
c906108c
SS
6942 }
6943 }
6944 else
6945 map_breakpoint_numbers (arg, delete_breakpoint);
6946}
6947
6948/* Reset a breakpoint given it's struct breakpoint * BINT.
6949 The value we return ends up being the return value from catch_errors.
6950 Unused in this case. */
6951
6952static int
4efb68b1 6953breakpoint_re_set_one (void *bint)
c906108c 6954{
53a5351d
JM
6955 /* get past catch_errs */
6956 struct breakpoint *b = (struct breakpoint *) bint;
c906108c
SS
6957 struct value *mark;
6958 int i;
84acb35a
JJ
6959 int not_found;
6960 int *not_found_ptr = NULL;
c906108c
SS
6961 struct symtabs_and_lines sals;
6962 char *s;
b5de0fa7 6963 enum enable_state save_enable;
c906108c
SS
6964
6965 switch (b->type)
6966 {
6967 case bp_none:
53a5351d
JM
6968 warning ("attempted to reset apparently deleted breakpoint #%d?",
6969 b->number);
c906108c
SS
6970 return 0;
6971 case bp_breakpoint:
6972 case bp_hardware_breakpoint:
6973 case bp_catch_load:
6974 case bp_catch_unload:
6975 if (b->addr_string == NULL)
6976 {
6977 /* Anything without a string can't be re-set. */
6978 delete_breakpoint (b);
6979 return 0;
6980 }
b18c45ed
AC
6981 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
6982
6983 ``And a hack it is, although Apple's Darwin version of GDB
6984 contains an almost identical hack to implement a "future
6985 break" command. It seems to work in many real world cases,
6986 but it is easy to come up with a test case where the patch
6987 doesn't help at all.''
6988
6989 ``It seems that the way GDB implements breakpoints - in -
6990 shared - libraries was designed for a.out shared library
6991 systems (SunOS 4) where shared libraries were loaded at a
6992 fixed address in memory. Since ELF shared libraries can (and
6993 will) be loaded at any address in memory, things break.
6994 Fixing this is not trivial. Therefore, I'm not sure whether
6995 we should add this hack to the branch only. I cannot
6996 guarantee that things will be fixed on the trunk in the near
6997 future.''
6998
6999 In case we have a problem, disable this breakpoint. We'll
7000 restore its status if we succeed. Don't disable a
7001 shlib_disabled breakpoint though. There's a fair chance we
7002 can't re-set it if the shared library it's in hasn't been
7003 loaded yet. */
0101ce28
JJ
7004
7005 if (b->pending)
7006 break;
7007
b5de0fa7 7008 save_enable = b->enable_state;
b18c45ed
AC
7009 if (b->enable_state != bp_shlib_disabled)
7010 b->enable_state = bp_disabled;
84acb35a
JJ
7011 else
7012 /* If resetting a shlib-disabled breakpoint, we don't want to
7013 see an error message if it is not found since we will expect
7014 this to occur until the shared library is finally reloaded.
7015 We accomplish this by giving decode_line_1 a pointer to use
7016 for silent notification that the symbol is not found. */
7017 not_found_ptr = &not_found;
c906108c
SS
7018
7019 set_language (b->language);
7020 input_radix = b->input_radix;
7021 s = b->addr_string;
84acb35a
JJ
7022 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL,
7023 not_found_ptr);
c906108c
SS
7024 for (i = 0; i < sals.nelts; i++)
7025 {
7026 resolve_sal_pc (&sals.sals[i]);
7027
7028 /* Reparse conditions, they might contain references to the
7029 old symtab. */
7030 if (b->cond_string != NULL)
7031 {
7032 s = b->cond_string;
7033 if (b->cond)
fad0733a
DJ
7034 {
7035 xfree (b->cond);
7036 /* Avoid re-freeing b->exp if an error during the call
7037 to parse_exp_1. */
7038 b->cond = NULL;
7039 }
c906108c
SS
7040 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
7041 }
7042
c5aa993b 7043 /* We need to re-set the breakpoint if the address changes... */
5cab636d 7044 if (b->loc->address != sals.sals[i].pc
c5aa993b
JM
7045 /* ...or new and old breakpoints both have source files, and
7046 the source file name or the line number changes... */
c906108c
SS
7047 || (b->source_file != NULL
7048 && sals.sals[i].symtab != NULL
6314a349 7049 && (strcmp (b->source_file, sals.sals[i].symtab->filename) != 0
c906108c 7050 || b->line_number != sals.sals[i].line)
c906108c 7051 )
c5aa993b
JM
7052 /* ...or we switch between having a source file and not having
7053 one. */
7054 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
7055 )
c906108c
SS
7056 {
7057 if (b->source_file != NULL)
b8c9b27d 7058 xfree (b->source_file);
c906108c
SS
7059 if (sals.sals[i].symtab == NULL)
7060 b->source_file = NULL;
7061 else
7062 b->source_file =
7063 savestring (sals.sals[i].symtab->filename,
7064 strlen (sals.sals[i].symtab->filename));
7065 b->line_number = sals.sals[i].line;
5cab636d
DJ
7066 b->loc->requested_address = sals.sals[i].pc;
7067 b->loc->address
88f7da05
KB
7068 = adjust_breakpoint_address (b->loc->requested_address,
7069 b->type);
c906108c 7070
c5aa993b 7071 /* Used to check for duplicates here, but that can
261c4ca2 7072 cause trouble, as it doesn't check for disabled
c5aa993b 7073 breakpoints. */
c906108c
SS
7074
7075 mention (b);
7076
7077 /* Might be better to do this just once per breakpoint_re_set,
c5aa993b 7078 rather than once for every breakpoint. */
c906108c
SS
7079 breakpoints_changed ();
7080 }
cf3a9e5b 7081 b->loc->section = sals.sals[i].section;
b5de0fa7 7082 b->enable_state = save_enable; /* Restore it, this worked. */
c906108c
SS
7083
7084
c5aa993b 7085 /* Now that this is re-enabled, check_duplicates
c906108c 7086 can be used. */
9f60f21b 7087 check_duplicates (b);
c906108c
SS
7088
7089 }
b8c9b27d 7090 xfree (sals.sals);
c906108c
SS
7091 break;
7092
7093 case bp_watchpoint:
7094 case bp_hardware_watchpoint:
7095 case bp_read_watchpoint:
7096 case bp_access_watchpoint:
7097 innermost_block = NULL;
53a5351d
JM
7098 /* The issue arises of what context to evaluate this in. The
7099 same one as when it was set, but what does that mean when
7100 symbols have been re-read? We could save the filename and
7101 functionname, but if the context is more local than that, the
7102 best we could do would be something like how many levels deep
7103 and which index at that particular level, but that's going to
7104 be less stable than filenames or function names. */
7105
c906108c
SS
7106 /* So for now, just use a global context. */
7107 if (b->exp)
a355c7de
AC
7108 {
7109 xfree (b->exp);
7110 /* Avoid re-freeing b->exp if an error during the call to
7111 parse_expression. */
7112 b->exp = NULL;
7113 }
c906108c
SS
7114 b->exp = parse_expression (b->exp_string);
7115 b->exp_valid_block = innermost_block;
7116 mark = value_mark ();
7117 if (b->val)
a355c7de
AC
7118 {
7119 value_free (b->val);
7120 /* Avoid re-freeing b->val if an error during the call to
7121 evaluate_expression. */
7122 b->val = NULL;
7123 }
c906108c
SS
7124 b->val = evaluate_expression (b->exp);
7125 release_value (b->val);
468d015d 7126 if (VALUE_LAZY (b->val) && breakpoint_enabled (b))
c906108c
SS
7127 value_fetch_lazy (b->val);
7128
7129 if (b->cond_string != NULL)
7130 {
7131 s = b->cond_string;
7132 if (b->cond)
a355c7de
AC
7133 {
7134 xfree (b->cond);
7135 /* Avoid re-freeing b->exp if an error during the call
7136 to parse_exp_1. */
7137 b->cond = NULL;
7138 }
c5aa993b 7139 b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
c906108c 7140 }
468d015d 7141 if (breakpoint_enabled (b))
c906108c
SS
7142 mention (b);
7143 value_free_to_mark (mark);
7144 break;
c5aa993b
JM
7145 case bp_catch_catch:
7146 case bp_catch_throw:
c906108c 7147 break;
c5aa993b
JM
7148 /* We needn't really do anything to reset these, since the mask
7149 that requests them is unaffected by e.g., new libraries being
7150 loaded. */
c906108c
SS
7151 case bp_catch_fork:
7152 case bp_catch_vfork:
7153 case bp_catch_exec:
7154 break;
c5aa993b 7155
c906108c
SS
7156 default:
7157 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
7158 /* fall through */
1900040c
MS
7159 /* Delete longjmp and overlay event breakpoints; they will be
7160 reset later by breakpoint_re_set. */
c906108c
SS
7161 case bp_longjmp:
7162 case bp_longjmp_resume:
1900040c 7163 case bp_overlay_event:
c906108c
SS
7164 delete_breakpoint (b);
7165 break;
7166
c5aa993b
JM
7167 /* This breakpoint is special, it's set up when the inferior
7168 starts and we really don't want to touch it. */
c906108c
SS
7169 case bp_shlib_event:
7170
c4093a6a
JM
7171 /* Like bp_shlib_event, this breakpoint type is special.
7172 Once it is set up, we do not want to touch it. */
7173 case bp_thread_event:
7174
c5aa993b
JM
7175 /* Keep temporary breakpoints, which can be encountered when we step
7176 over a dlopen call and SOLIB_ADD is resetting the breakpoints.
7177 Otherwise these should have been blown away via the cleanup chain
7178 or by breakpoint_init_inferior when we rerun the executable. */
c906108c
SS
7179 case bp_until:
7180 case bp_finish:
7181 case bp_watchpoint_scope:
7182 case bp_call_dummy:
7183 case bp_step_resume:
7184 break;
7185 }
7186
7187 return 0;
7188}
7189
7190/* Re-set all breakpoints after symbols have been re-loaded. */
7191void
fba45db2 7192breakpoint_re_set (void)
c906108c
SS
7193{
7194 struct breakpoint *b, *temp;
7195 enum language save_language;
7196 int save_input_radix;
c5aa993b 7197
c906108c
SS
7198 save_language = current_language->la_language;
7199 save_input_radix = input_radix;
7200 ALL_BREAKPOINTS_SAFE (b, temp)
c5aa993b 7201 {
53a5351d 7202 /* Format possible error msg */
9ebf4acf
AC
7203 char *message = xstrprintf ("Error in re-setting breakpoint %d:\n",
7204 b->number);
7205 struct cleanup *cleanups = make_cleanup (xfree, message);
c5aa993b 7206 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
9ebf4acf 7207 do_cleanups (cleanups);
c5aa993b 7208 }
c906108c
SS
7209 set_language (save_language);
7210 input_radix = save_input_radix;
7211
9df628e0
RE
7212 if (GET_LONGJMP_TARGET_P ())
7213 {
7214 create_longjmp_breakpoint ("longjmp");
7215 create_longjmp_breakpoint ("_longjmp");
7216 create_longjmp_breakpoint ("siglongjmp");
7217 create_longjmp_breakpoint ("_siglongjmp");
7218 create_longjmp_breakpoint (NULL);
7219 }
1900040c
MS
7220
7221 create_overlay_event_breakpoint ("_ovly_debug_event");
c906108c
SS
7222}
7223\f
c906108c
SS
7224/* Reset the thread number of this breakpoint:
7225
7226 - If the breakpoint is for all threads, leave it as-is.
39f77062 7227 - Else, reset it to the current thread for inferior_ptid. */
c906108c 7228void
fba45db2 7229breakpoint_re_set_thread (struct breakpoint *b)
c906108c
SS
7230{
7231 if (b->thread != -1)
7232 {
39f77062
KB
7233 if (in_thread_list (inferior_ptid))
7234 b->thread = pid_to_thread_id (inferior_ptid);
c906108c
SS
7235 }
7236}
7237
03ac34d5
MS
7238/* Set ignore-count of breakpoint number BPTNUM to COUNT.
7239 If from_tty is nonzero, it prints a message to that effect,
7240 which ends with a period (no newline). */
7241
c906108c 7242void
fba45db2 7243set_ignore_count (int bptnum, int count, int from_tty)
c906108c 7244{
52f0bd74 7245 struct breakpoint *b;
c906108c
SS
7246
7247 if (count < 0)
7248 count = 0;
7249
7250 ALL_BREAKPOINTS (b)
7251 if (b->number == bptnum)
c5aa993b
JM
7252 {
7253 b->ignore_count = count;
221ea385
KS
7254 if (from_tty)
7255 {
7256 if (count == 0)
7257 printf_filtered ("Will stop next time breakpoint %d is reached.",
7258 bptnum);
7259 else if (count == 1)
7260 printf_filtered ("Will ignore next crossing of breakpoint %d.",
7261 bptnum);
7262 else
7263 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
7264 count, bptnum);
7265 }
c5aa993b 7266 breakpoints_changed ();
221ea385 7267 breakpoint_modify_event (b->number);
c5aa993b
JM
7268 return;
7269 }
c906108c
SS
7270
7271 error ("No breakpoint number %d.", bptnum);
7272}
7273
7274/* Clear the ignore counts of all breakpoints. */
7275void
fba45db2 7276breakpoint_clear_ignore_counts (void)
c906108c
SS
7277{
7278 struct breakpoint *b;
7279
7280 ALL_BREAKPOINTS (b)
7281 b->ignore_count = 0;
7282}
7283
7284/* Command to set ignore-count of breakpoint N to COUNT. */
7285
7286static void
fba45db2 7287ignore_command (char *args, int from_tty)
c906108c
SS
7288{
7289 char *p = args;
52f0bd74 7290 int num;
c906108c
SS
7291
7292 if (p == 0)
7293 error_no_arg ("a breakpoint number");
c5aa993b 7294
c906108c 7295 num = get_number (&p);
5c44784c
JM
7296 if (num == 0)
7297 error ("bad breakpoint number: '%s'", args);
c906108c
SS
7298 if (*p == 0)
7299 error ("Second argument (specified ignore-count) is missing.");
7300
7301 set_ignore_count (num,
7302 longest_to_int (value_as_long (parse_and_eval (p))),
7303 from_tty);
221ea385
KS
7304 if (from_tty)
7305 printf_filtered ("\n");
c906108c
SS
7306}
7307\f
7308/* Call FUNCTION on each of the breakpoints
7309 whose numbers are given in ARGS. */
7310
7311static void
831662b3 7312map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
c906108c 7313{
52f0bd74 7314 char *p = args;
c906108c 7315 char *p1;
52f0bd74
AC
7316 int num;
7317 struct breakpoint *b, *tmp;
11cf8741 7318 int match;
c906108c
SS
7319
7320 if (p == 0)
7321 error_no_arg ("one or more breakpoint numbers");
7322
7323 while (*p)
7324 {
11cf8741 7325 match = 0;
c906108c 7326 p1 = p;
c5aa993b 7327
5c44784c
JM
7328 num = get_number_or_range (&p1);
7329 if (num == 0)
c5aa993b 7330 {
5c44784c
JM
7331 warning ("bad breakpoint number at or near '%s'", p);
7332 }
7333 else
7334 {
7335 ALL_BREAKPOINTS_SAFE (b, tmp)
7336 if (b->number == num)
7337 {
7338 struct breakpoint *related_breakpoint = b->related_breakpoint;
11cf8741 7339 match = 1;
5c44784c
JM
7340 function (b);
7341 if (related_breakpoint)
7342 function (related_breakpoint);
11cf8741 7343 break;
5c44784c 7344 }
11cf8741
JM
7345 if (match == 0)
7346 printf_unfiltered ("No breakpoint number %d.\n", num);
c5aa993b 7347 }
c906108c
SS
7348 p = p1;
7349 }
7350}
7351
1900040c
MS
7352/* Set ignore-count of breakpoint number BPTNUM to COUNT.
7353 If from_tty is nonzero, it prints a message to that effect,
7354 which ends with a period (no newline). */
7355
c906108c 7356void
fba45db2 7357disable_breakpoint (struct breakpoint *bpt)
c906108c
SS
7358{
7359 /* Never disable a watchpoint scope breakpoint; we want to
7360 hit them when we leave scope so we can delete both the
7361 watchpoint and its scope breakpoint at that time. */
7362 if (bpt->type == bp_watchpoint_scope)
7363 return;
7364
c2c6d25f 7365 /* You can't disable permanent breakpoints. */
b5de0fa7 7366 if (bpt->enable_state == bp_permanent)
c2c6d25f
JM
7367 return;
7368
b5de0fa7 7369 bpt->enable_state = bp_disabled;
c906108c 7370
9f60f21b 7371 check_duplicates (bpt);
c906108c 7372
9a4105ab
AC
7373 if (deprecated_modify_breakpoint_hook)
7374 deprecated_modify_breakpoint_hook (bpt);
104c1213 7375 breakpoint_modify_event (bpt->number);
c906108c
SS
7376}
7377
c906108c 7378static void
fba45db2 7379disable_command (char *args, int from_tty)
c906108c 7380{
52f0bd74 7381 struct breakpoint *bpt;
c906108c
SS
7382 if (args == 0)
7383 ALL_BREAKPOINTS (bpt)
7384 switch (bpt->type)
c5aa993b
JM
7385 {
7386 case bp_none:
53a5351d
JM
7387 warning ("attempted to disable apparently deleted breakpoint #%d?",
7388 bpt->number);
c5aa993b
JM
7389 continue;
7390 case bp_breakpoint:
7391 case bp_catch_load:
7392 case bp_catch_unload:
7393 case bp_catch_fork:
7394 case bp_catch_vfork:
7395 case bp_catch_exec:
7396 case bp_catch_catch:
7397 case bp_catch_throw:
7398 case bp_hardware_breakpoint:
7399 case bp_watchpoint:
7400 case bp_hardware_watchpoint:
7401 case bp_read_watchpoint:
7402 case bp_access_watchpoint:
7403 disable_breakpoint (bpt);
7404 default:
7405 continue;
7406 }
c906108c
SS
7407 else
7408 map_breakpoint_numbers (args, disable_breakpoint);
7409}
7410
7411static void
fba45db2 7412do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
c906108c 7413{
c906108c
SS
7414 int target_resources_ok, other_type_used;
7415 struct value *mark;
7416
7417 if (bpt->type == bp_hardware_breakpoint)
7418 {
7419 int i;
c5aa993b 7420 i = hw_breakpoint_used_count ();
53a5351d
JM
7421 target_resources_ok =
7422 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint,
7423 i + 1, 0);
c906108c 7424 if (target_resources_ok == 0)
c5aa993b 7425 error ("No hardware breakpoint support in the target.");
c906108c 7426 else if (target_resources_ok < 0)
c5aa993b 7427 error ("Hardware breakpoints used exceeds limit.");
c906108c
SS
7428 }
7429
0101ce28 7430 if (bpt->pending)
c906108c 7431 {
0101ce28 7432 if (bpt->enable_state != bp_enabled)
c906108c 7433 {
0101ce28
JJ
7434 /* When enabling a pending breakpoint, we need to check if the breakpoint
7435 is resolvable since shared libraries could have been loaded
7436 after the breakpoint was disabled. */
7437 breakpoints_changed ();
7438 if (resolve_pending_breakpoint (bpt) == GDB_RC_OK)
c906108c 7439 {
0101ce28 7440 delete_breakpoint (bpt);
c906108c
SS
7441 return;
7442 }
0101ce28
JJ
7443 bpt->enable_state = bp_enabled;
7444 bpt->disposition = disposition;
c906108c 7445 }
0101ce28
JJ
7446 }
7447 else /* Not a pending breakpoint. */
7448 {
7449 if (bpt->enable_state != bp_permanent)
7450 bpt->enable_state = bp_enabled;
7451 bpt->disposition = disposition;
7452 check_duplicates (bpt);
7453 breakpoints_changed ();
7454
7455 if (bpt->type == bp_watchpoint ||
7456 bpt->type == bp_hardware_watchpoint ||
7457 bpt->type == bp_read_watchpoint ||
c5aa993b
JM
7458 bpt->type == bp_access_watchpoint)
7459 {
7789d0fa
AC
7460 struct frame_id saved_frame_id;
7461
b04f3ab4 7462 saved_frame_id = get_frame_id (get_selected_frame (NULL));
0101ce28
JJ
7463 if (bpt->exp_valid_block != NULL)
7464 {
7465 struct frame_info *fr =
7466 fr = frame_find_by_id (bpt->watchpoint_frame);
7467 if (fr == NULL)
7468 {
7469 printf_filtered ("\
7470Cannot enable watchpoint %d because the block in which its expression\n\
7471is valid is not currently in scope.\n", bpt->number);
7472 bpt->enable_state = bp_disabled;
7473 return;
7474 }
0101ce28
JJ
7475 select_frame (fr);
7476 }
7477
7478 value_free (bpt->val);
7479 mark = value_mark ();
7480 bpt->val = evaluate_expression (bpt->exp);
7481 release_value (bpt->val);
7482 if (VALUE_LAZY (bpt->val))
7483 value_fetch_lazy (bpt->val);
7484
7485 if (bpt->type == bp_hardware_watchpoint ||
7486 bpt->type == bp_read_watchpoint ||
7487 bpt->type == bp_access_watchpoint)
c5aa993b 7488 {
0101ce28
JJ
7489 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
7490 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
7491
7492 /* Hack around 'unused var' error for some targets here */
7493 (void) mem_cnt, i;
7494 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
7495 bpt->type, i + mem_cnt, other_type_used);
7496 /* we can consider of type is bp_hardware_watchpoint, convert to
7497 bp_watchpoint in the following condition */
7498 if (target_resources_ok < 0)
7499 {
7500 printf_filtered ("\
c906108c
SS
7501Cannot enable watchpoint %d because target watch resources\n\
7502have been allocated for other watchpoints.\n", bpt->number);
0101ce28
JJ
7503 bpt->enable_state = bp_disabled;
7504 value_free_to_mark (mark);
7505 return;
7506 }
c5aa993b 7507 }
0101ce28 7508
7789d0fa 7509 select_frame (frame_find_by_id (saved_frame_id));
0101ce28 7510 value_free_to_mark (mark);
c5aa993b 7511 }
c906108c 7512 }
0101ce28 7513
9a4105ab
AC
7514 if (deprecated_modify_breakpoint_hook)
7515 deprecated_modify_breakpoint_hook (bpt);
104c1213 7516 breakpoint_modify_event (bpt->number);
c906108c
SS
7517}
7518
7519void
fba45db2 7520enable_breakpoint (struct breakpoint *bpt)
c906108c
SS
7521{
7522 do_enable_breakpoint (bpt, bpt->disposition);
7523}
7524
7525/* The enable command enables the specified breakpoints (or all defined
7526 breakpoints) so they once again become (or continue to be) effective
1272ad14 7527 in stopping the inferior. */
c906108c 7528
c906108c 7529static void
fba45db2 7530enable_command (char *args, int from_tty)
c906108c 7531{
52f0bd74 7532 struct breakpoint *bpt;
c906108c
SS
7533 if (args == 0)
7534 ALL_BREAKPOINTS (bpt)
7535 switch (bpt->type)
c5aa993b
JM
7536 {
7537 case bp_none:
53a5351d
JM
7538 warning ("attempted to enable apparently deleted breakpoint #%d?",
7539 bpt->number);
c5aa993b
JM
7540 continue;
7541 case bp_breakpoint:
7542 case bp_catch_load:
7543 case bp_catch_unload:
7544 case bp_catch_fork:
7545 case bp_catch_vfork:
7546 case bp_catch_exec:
7547 case bp_catch_catch:
7548 case bp_catch_throw:
7549 case bp_hardware_breakpoint:
7550 case bp_watchpoint:
7551 case bp_hardware_watchpoint:
7552 case bp_read_watchpoint:
7553 case bp_access_watchpoint:
7554 enable_breakpoint (bpt);
7555 default:
7556 continue;
7557 }
c906108c
SS
7558 else
7559 map_breakpoint_numbers (args, enable_breakpoint);
7560}
7561
7562static void
fba45db2 7563enable_once_breakpoint (struct breakpoint *bpt)
c906108c 7564{
b5de0fa7 7565 do_enable_breakpoint (bpt, disp_disable);
c906108c
SS
7566}
7567
c906108c 7568static void
fba45db2 7569enable_once_command (char *args, int from_tty)
c906108c
SS
7570{
7571 map_breakpoint_numbers (args, enable_once_breakpoint);
7572}
7573
7574static void
fba45db2 7575enable_delete_breakpoint (struct breakpoint *bpt)
c906108c 7576{
b5de0fa7 7577 do_enable_breakpoint (bpt, disp_del);
c906108c
SS
7578}
7579
c906108c 7580static void
fba45db2 7581enable_delete_command (char *args, int from_tty)
c906108c
SS
7582{
7583 map_breakpoint_numbers (args, enable_delete_breakpoint);
7584}
7585\f
fa8d40ab
JJ
7586static void
7587set_breakpoint_cmd (char *args, int from_tty)
7588{
7589}
7590
7591static void
7592show_breakpoint_cmd (char *args, int from_tty)
7593{
7594}
7595
c906108c
SS
7596/* Use default_breakpoint_'s, or nothing if they aren't valid. */
7597
7598struct symtabs_and_lines
fba45db2 7599decode_line_spec_1 (char *string, int funfirstline)
c906108c
SS
7600{
7601 struct symtabs_and_lines sals;
7602 if (string == 0)
7603 error ("Empty line specification.");
7604 if (default_breakpoint_valid)
7605 sals = decode_line_1 (&string, funfirstline,
53a5351d
JM
7606 default_breakpoint_symtab,
7607 default_breakpoint_line,
68219205 7608 (char ***) NULL, NULL);
c906108c
SS
7609 else
7610 sals = decode_line_1 (&string, funfirstline,
68219205 7611 (struct symtab *) NULL, 0, (char ***) NULL, NULL);
c906108c
SS
7612 if (*string)
7613 error ("Junk at end of line specification: %s", string);
7614 return sals;
7615}
7616\f
7617void
fba45db2 7618_initialize_breakpoint (void)
c906108c 7619{
fa8d40ab
JJ
7620 static struct cmd_list_element *breakpoint_set_cmdlist;
7621 static struct cmd_list_element *breakpoint_show_cmdlist;
c906108c
SS
7622 struct cmd_list_element *c;
7623
84acb35a
JJ
7624#ifdef SOLIB_ADD
7625 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib);
7626#endif
7627
c906108c
SS
7628 breakpoint_chain = 0;
7629 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
7630 before a breakpoint is set. */
7631 breakpoint_count = 0;
7632
7633 add_com ("ignore", class_breakpoint, ignore_command,
7634 "Set ignore-count of breakpoint number N to COUNT.\n\
7635Usage is `ignore N COUNT'.");
7636 if (xdb_commands)
c5aa993b 7637 add_com_alias ("bc", "ignore", class_breakpoint, 1);
c906108c
SS
7638
7639 add_com ("commands", class_breakpoint, commands_command,
7640 "Set commands to be executed when a breakpoint is hit.\n\
7641Give breakpoint number as argument after \"commands\".\n\
7642With no argument, the targeted breakpoint is the last one set.\n\
7643The commands themselves follow starting on the next line.\n\
7644Type a line containing \"end\" to indicate the end of them.\n\
7645Give \"silent\" as the first line to make the breakpoint silent;\n\
7646then no output is printed when it is hit, except what the commands print.");
7647
7648 add_com ("condition", class_breakpoint, condition_command,
7649 "Specify breakpoint number N to break only if COND is true.\n\
7650Usage is `condition N COND', where N is an integer and COND is an\n\
d4654627 7651expression to be evaluated whenever breakpoint N is reached.");
c906108c 7652
c94fdfd0
EZ
7653 c = add_com ("tbreak", class_breakpoint, tbreak_command,
7654 "Set a temporary breakpoint. Args like \"break\" command.\n\
c906108c
SS
7655Like \"break\" except the breakpoint is only temporary,\n\
7656so it will be deleted when hit. Equivalent to \"break\" followed\n\
7657by using \"enable delete\" on the breakpoint number.");
5ba2abeb 7658 set_cmd_completer (c, location_completer);
c94fdfd0 7659
c94fdfd0
EZ
7660 c = add_com ("hbreak", class_breakpoint, hbreak_command,
7661 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
c906108c
SS
7662Like \"break\" except the breakpoint requires hardware support,\n\
7663some target hardware may not have this support.");
5ba2abeb 7664 set_cmd_completer (c, location_completer);
c906108c 7665
c94fdfd0
EZ
7666 c = add_com ("thbreak", class_breakpoint, thbreak_command,
7667 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
c906108c
SS
7668Like \"hbreak\" except the breakpoint is only temporary,\n\
7669so it will be deleted when hit.");
5ba2abeb 7670 set_cmd_completer (c, location_completer);
c906108c
SS
7671
7672 add_prefix_cmd ("enable", class_breakpoint, enable_command,
7673 "Enable some breakpoints.\n\
7674Give breakpoint numbers (separated by spaces) as arguments.\n\
7675With no subcommand, breakpoints are enabled until you command otherwise.\n\
7676This is used to cancel the effect of the \"disable\" command.\n\
7677With a subcommand you can enable temporarily.",
7678 &enablelist, "enable ", 1, &cmdlist);
7679 if (xdb_commands)
c5aa993b
JM
7680 add_com ("ab", class_breakpoint, enable_command,
7681 "Enable some breakpoints.\n\
c906108c
SS
7682Give breakpoint numbers (separated by spaces) as arguments.\n\
7683With no subcommand, breakpoints are enabled until you command otherwise.\n\
7684This is used to cancel the effect of the \"disable\" command.\n\
7685With a subcommand you can enable temporarily.");
7686
7687 add_com_alias ("en", "enable", class_breakpoint, 1);
7688
7689 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
c5aa993b 7690 "Enable some breakpoints.\n\
c906108c
SS
7691Give breakpoint numbers (separated by spaces) as arguments.\n\
7692This is used to cancel the effect of the \"disable\" command.\n\
7693May be abbreviated to simply \"enable\".\n",
c5aa993b 7694 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
c906108c
SS
7695
7696 add_cmd ("once", no_class, enable_once_command,
7697 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7698If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7699 &enablebreaklist);
7700
7701 add_cmd ("delete", no_class, enable_delete_command,
7702 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7703If a breakpoint is hit while enabled in this fashion, it is deleted.",
7704 &enablebreaklist);
7705
7706 add_cmd ("delete", no_class, enable_delete_command,
7707 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
7708If a breakpoint is hit while enabled in this fashion, it is deleted.",
7709 &enablelist);
7710
7711 add_cmd ("once", no_class, enable_once_command,
7712 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
7713If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
7714 &enablelist);
7715
7716 add_prefix_cmd ("disable", class_breakpoint, disable_command,
c5aa993b 7717 "Disable some breakpoints.\n\
c906108c
SS
7718Arguments are breakpoint numbers with spaces in between.\n\
7719To disable all breakpoints, give no argument.\n\
7720A disabled breakpoint is not forgotten, but has no effect until reenabled.",
7721 &disablelist, "disable ", 1, &cmdlist);
7722 add_com_alias ("dis", "disable", class_breakpoint, 1);
7723 add_com_alias ("disa", "disable", class_breakpoint, 1);
7724 if (xdb_commands)
c5aa993b
JM
7725 add_com ("sb", class_breakpoint, disable_command,
7726 "Disable some breakpoints.\n\
c906108c
SS
7727Arguments are breakpoint numbers with spaces in between.\n\
7728To disable all breakpoints, give no argument.\n\
7729A disabled breakpoint is not forgotten, but has no effect until reenabled.");
7730
7731 add_cmd ("breakpoints", class_alias, disable_command,
7732 "Disable some breakpoints.\n\
7733Arguments are breakpoint numbers with spaces in between.\n\
7734To disable all breakpoints, give no argument.\n\
7735A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
7736This command may be abbreviated \"disable\".",
7737 &disablelist);
7738
7739 add_prefix_cmd ("delete", class_breakpoint, delete_command,
c5aa993b 7740 "Delete some breakpoints or auto-display expressions.\n\
c906108c
SS
7741Arguments are breakpoint numbers with spaces in between.\n\
7742To delete all breakpoints, give no argument.\n\
7743\n\
7744Also a prefix command for deletion of other GDB objects.\n\
7745The \"unset\" command is also an alias for \"delete\".",
7746 &deletelist, "delete ", 1, &cmdlist);
7747 add_com_alias ("d", "delete", class_breakpoint, 1);
7748 if (xdb_commands)
7749 add_com ("db", class_breakpoint, delete_command,
c5aa993b 7750 "Delete some breakpoints.\n\
c906108c
SS
7751Arguments are breakpoint numbers with spaces in between.\n\
7752To delete all breakpoints, give no argument.\n");
7753
7754 add_cmd ("breakpoints", class_alias, delete_command,
7755 "Delete some breakpoints or auto-display expressions.\n\
7756Arguments are breakpoint numbers with spaces in between.\n\
7757To delete all breakpoints, give no argument.\n\
7758This command may be abbreviated \"delete\".",
7759 &deletelist);
7760
7761 add_com ("clear", class_breakpoint, clear_command,
7762 concat ("Clear breakpoint at specified line or function.\n\
7763Argument may be line number, function name, or \"*\" and an address.\n\
7764If line number is specified, all breakpoints in that line are cleared.\n\
7765If function is specified, breakpoints at beginning of function are cleared.\n\
7766If an address is specified, breakpoints at that address are cleared.\n\n",
c5aa993b 7767 "With no argument, clears all breakpoints in the line that the selected frame\n\
c906108c
SS
7768is executing in.\n\
7769\n\
7770See also the \"delete\" command which clears breakpoints by number.", NULL));
7771
c94fdfd0
EZ
7772 c = add_com ("break", class_breakpoint, break_command,
7773 concat ("Set breakpoint at specified line or function.\n\
c906108c
SS
7774Argument may be line number, function name, or \"*\" and an address.\n\
7775If line number is specified, break at start of code for that line.\n\
7776If function is specified, break at start of code for that function.\n\
7777If an address is specified, break at that exact address.\n",
c5aa993b 7778 "With no arg, uses current execution address of selected stack frame.\n\
c906108c
SS
7779This is useful for breaking on return to a stack frame.\n\
7780\n\
7781Multiple breakpoints at one place are permitted, and useful if conditional.\n\
7782\n\
7783Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
5ba2abeb 7784 set_cmd_completer (c, location_completer);
c94fdfd0 7785
c906108c
SS
7786 add_com_alias ("b", "break", class_run, 1);
7787 add_com_alias ("br", "break", class_run, 1);
7788 add_com_alias ("bre", "break", class_run, 1);
7789 add_com_alias ("brea", "break", class_run, 1);
7790
502fd408 7791 if (xdb_commands)
c906108c
SS
7792 {
7793 add_com_alias ("ba", "break", class_breakpoint, 1);
7794 add_com_alias ("bu", "ubreak", class_breakpoint, 1);
c906108c
SS
7795 }
7796
7797 if (dbx_commands)
7798 {
c5aa993b
JM
7799 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
7800 "Break in function/address or break at a line in the current file.",
7801 &stoplist, "stop ", 1, &cmdlist);
7802 add_cmd ("in", class_breakpoint, stopin_command,
7803 "Break in function or address.\n", &stoplist);
7804 add_cmd ("at", class_breakpoint, stopat_command,
7805 "Break at a line in the current file.\n", &stoplist);
7806 add_com ("status", class_info, breakpoints_info,
7807 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
c906108c
SS
7808The \"Type\" column indicates one of:\n\
7809\tbreakpoint - normal breakpoint\n\
7810\twatchpoint - watchpoint\n\
7811The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7812the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7813breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7814address and file/line number respectively.\n\n",
c5aa993b 7815 "Convenience variable \"$_\" and default examine address for \"x\"\n\
c906108c
SS
7816are set to the address of the last breakpoint listed.\n\n\
7817Convenience variable \"$bpnum\" contains the number of the last\n\
7818breakpoint set.", NULL));
7819 }
7820
7821 add_info ("breakpoints", breakpoints_info,
7822 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
7823The \"Type\" column indicates one of:\n\
7824\tbreakpoint - normal breakpoint\n\
7825\twatchpoint - watchpoint\n\
7826The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7827the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7828breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7829address and file/line number respectively.\n\n",
c5aa993b 7830 "Convenience variable \"$_\" and default examine address for \"x\"\n\
c906108c
SS
7831are set to the address of the last breakpoint listed.\n\n\
7832Convenience variable \"$bpnum\" contains the number of the last\n\
7833breakpoint set.", NULL));
7834
7835 if (xdb_commands)
c5aa993b
JM
7836 add_com ("lb", class_breakpoint, breakpoints_info,
7837 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
c906108c
SS
7838The \"Type\" column indicates one of:\n\
7839\tbreakpoint - normal breakpoint\n\
7840\twatchpoint - watchpoint\n\
7841The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
7842the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7843breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7844address and file/line number respectively.\n\n",
c5aa993b 7845 "Convenience variable \"$_\" and default examine address for \"x\"\n\
c906108c
SS
7846are set to the address of the last breakpoint listed.\n\n\
7847Convenience variable \"$bpnum\" contains the number of the last\n\
7848breakpoint set.", NULL));
7849
c906108c 7850 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
c5aa993b 7851 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
c906108c
SS
7852The \"Type\" column indicates one of:\n\
7853\tbreakpoint - normal breakpoint\n\
7854\twatchpoint - watchpoint\n\
7855\tlongjmp - internal breakpoint used to step through longjmp()\n\
7856\tlongjmp resume - internal breakpoint at the target of longjmp()\n\
7857\tuntil - internal breakpoint used by the \"until\" command\n\
7858\tfinish - internal breakpoint used by the \"finish\" command\n",
c5aa993b 7859 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
c906108c
SS
7860the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
7861breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
7862address and file/line number respectively.\n\n",
c5aa993b 7863 "Convenience variable \"$_\" and default examine address for \"x\"\n\
c906108c
SS
7864are set to the address of the last breakpoint listed.\n\n\
7865Convenience variable \"$bpnum\" contains the number of the last\n\
7866breakpoint set.", NULL),
7867 &maintenanceinfolist);
7868
c906108c 7869 add_com ("catch", class_breakpoint, catch_command,
c5aa993b 7870 "Set catchpoints to catch events.\n\
c906108c
SS
7871Raised signals may be caught:\n\
7872\tcatch signal - all signals\n\
7873\tcatch signal <signame> - a particular signal\n\
7874Raised exceptions may be caught:\n\
7875\tcatch throw - all exceptions, when thrown\n\
7876\tcatch throw <exceptname> - a particular exception, when thrown\n\
7877\tcatch catch - all exceptions, when caught\n\
7878\tcatch catch <exceptname> - a particular exception, when caught\n\
7879Thread or process events may be caught:\n\
7880\tcatch thread_start - any threads, just after creation\n\
7881\tcatch thread_exit - any threads, just before expiration\n\
7882\tcatch thread_join - any threads, just after joins\n\
7883Process events may be caught:\n\
7884\tcatch start - any processes, just after creation\n\
7885\tcatch exit - any processes, just before expiration\n\
7886\tcatch fork - calls to fork()\n\
7887\tcatch vfork - calls to vfork()\n\
7888\tcatch exec - calls to exec()\n\
7889Dynamically-linked library events may be caught:\n\
7890\tcatch load - loads of any library\n\
7891\tcatch load <libname> - loads of a particular library\n\
7892\tcatch unload - unloads of any library\n\
7893\tcatch unload <libname> - unloads of a particular library\n\
7894The act of your program's execution stopping may also be caught:\n\
7895\tcatch stop\n\n\
7896C++ exceptions may be caught:\n\
7897\tcatch throw - all exceptions, when thrown\n\
7898\tcatch catch - all exceptions, when caught\n\
7899\n\
7900Do \"help set follow-fork-mode\" for info on debugging your program\n\
7901after a fork or vfork is caught.\n\n\
7902Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
c5aa993b 7903
c906108c 7904 add_com ("tcatch", class_breakpoint, tcatch_command,
c5aa993b 7905 "Set temporary catchpoints to catch events.\n\
c906108c
SS
7906Args like \"catch\" command.\n\
7907Like \"catch\" except the catchpoint is only temporary,\n\
7908so it will be deleted when hit. Equivalent to \"catch\" followed\n\
7909by using \"enable delete\" on the catchpoint number.");
c5aa993b 7910
c94fdfd0
EZ
7911 c = add_com ("watch", class_breakpoint, watch_command,
7912 "Set a watchpoint for an expression.\n\
c906108c
SS
7913A watchpoint stops execution of your program whenever the value of\n\
7914an expression changes.");
5ba2abeb 7915 set_cmd_completer (c, location_completer);
c906108c 7916
c94fdfd0
EZ
7917 c = add_com ("rwatch", class_breakpoint, rwatch_command,
7918 "Set a read watchpoint for an expression.\n\
c906108c
SS
7919A watchpoint stops execution of your program whenever the value of\n\
7920an expression is read.");
5ba2abeb 7921 set_cmd_completer (c, location_completer);
c906108c 7922
c94fdfd0
EZ
7923 c = add_com ("awatch", class_breakpoint, awatch_command,
7924 "Set a watchpoint for an expression.\n\
c906108c
SS
7925A watchpoint stops execution of your program whenever the value of\n\
7926an expression is either read or written.");
5ba2abeb 7927 set_cmd_completer (c, location_completer);
c906108c
SS
7928
7929 add_info ("watchpoints", breakpoints_info,
7930 "Synonym for ``info breakpoints''.");
7931
7932
7933 c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
c5aa993b
JM
7934 (char *) &can_use_hw_watchpoints,
7935 "Set debugger's willingness to use watchpoint hardware.\n\
c906108c
SS
7936If zero, gdb will not use hardware for new watchpoints, even if\n\
7937such is available. (However, any hardware watchpoints that were\n\
7938created before setting this to nonzero, will continue to use watchpoint\n\
7939hardware.)",
c5aa993b 7940 &setlist);
cb1a6d5f 7941 deprecated_add_show_from_set (c, &showlist);
c906108c
SS
7942
7943 can_use_hw_watchpoints = 1;
fa8d40ab
JJ
7944
7945 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, "\
7946Breakpoint specific settings\n\
7947Configure various breakpoint-specific variables such as\n\
7948pending breakpoint behavior",
7949 &breakpoint_set_cmdlist, "set breakpoint ",
7950 0/*allow-unknown*/, &setlist);
7951 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, "\
7952Breakpoint specific settings\n\
7953Configure various breakpoint-specific variables such as\n\
7954pending breakpoint behavior",
7955 &breakpoint_show_cmdlist, "show breakpoint ",
7956 0/*allow-unknown*/, &showlist);
7957
6e1d7d6c 7958 add_setshow_auto_boolean_cmd ("pending", no_class, &pending_break_support, "\
3b64bf98
AC
7959Set debugger's behavior regarding pending breakpoints.", "\
7960Show debugger's behavior regarding pending breakpoints.", "\
6e1d7d6c
AC
7961If on, an unrecognized breakpoint location will cause gdb to create a\n\
7962pending breakpoint. If off, an unrecognized breakpoint location results in\n\
7963an error. If auto, an unrecognized breakpoint location results in a\n\
3b64bf98
AC
7964user-query to see if a pending breakpoint should be created.", "\
7965Debugger's behavior regarding pending breakpoints is %s.",
6e1d7d6c
AC
7966 NULL, NULL,
7967 &breakpoint_set_cmdlist,
7968 &breakpoint_show_cmdlist);
fa8d40ab
JJ
7969
7970 pending_break_support = AUTO_BOOLEAN_AUTO;
c906108c 7971}
This page took 0.861262 seconds and 4 git commands to generate.