* hppa-tdep.c (pa_print_registers): Extract register values stored
[deliverable/binutils-gdb.git] / gdb / breakpoint.c
CommitLineData
bd5635a1 1/* Everything about breakpoints, for GDB.
9f577285
SS
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
bd5635a1
RP
4
5This file is part of GDB.
6
bdbd5f50 7This program is free software; you can redistribute it and/or modify
bd5635a1 8it under the terms of the GNU General Public License as published by
bdbd5f50
JG
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
bd5635a1 11
bdbd5f50 12This program is distributed in the hope that it will be useful,
bd5635a1
RP
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
bdbd5f50
JG
18along with this program; if not, write to the Free Software
19Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
bd5635a1 20
bd5635a1 21#include "defs.h"
1eeba686 22#include <ctype.h>
bd5635a1
RP
23#include "symtab.h"
24#include "frame.h"
25#include "breakpoint.h"
30875e1c 26#include "gdbtypes.h"
bd5635a1
RP
27#include "expression.h"
28#include "gdbcore.h"
29#include "gdbcmd.h"
30#include "value.h"
31#include "ctype.h"
32#include "command.h"
33#include "inferior.h"
199b2450 34#include "thread.h"
bd5635a1 35#include "target.h"
d3b9c0df 36#include "language.h"
bd5635a1 37#include <string.h>
423e9664 38#include "demangle.h"
9f577285 39#include "annotate.h"
bd5635a1 40
30875e1c
SG
41/* local function prototypes */
42
43static void
44catch_command_1 PARAMS ((char *, int, int));
45
46static void
47enable_delete_command PARAMS ((char *, int));
48
49static void
50enable_delete_breakpoint PARAMS ((struct breakpoint *));
51
52static void
53enable_once_command PARAMS ((char *, int));
54
55static void
56enable_once_breakpoint PARAMS ((struct breakpoint *));
57
58static void
59disable_command PARAMS ((char *, int));
60
61static void
62disable_breakpoint PARAMS ((struct breakpoint *));
63
64static void
65enable_command PARAMS ((char *, int));
66
67static void
68enable_breakpoint PARAMS ((struct breakpoint *));
69
70static void
71map_breakpoint_numbers PARAMS ((char *, void (*)(struct breakpoint *)));
72
73static void
74ignore_command PARAMS ((char *, int));
75
76static int
77breakpoint_re_set_one PARAMS ((char *));
78
79static void
80delete_command PARAMS ((char *, int));
81
82static void
83clear_command PARAMS ((char *, int));
84
85static void
86catch_command PARAMS ((char *, int));
87
88static struct symtabs_and_lines
89get_catch_sals PARAMS ((int));
90
91static void
92watch_command PARAMS ((char *, int));
93
999dd04b 94static int
11054881 95can_use_hardware_watchpoint PARAMS ((struct value *));
999dd04b 96
30875e1c
SG
97static void
98tbreak_command PARAMS ((char *, int));
99
100static void
101break_command_1 PARAMS ((char *, int, int));
102
103static void
104mention PARAMS ((struct breakpoint *));
105
106static struct breakpoint *
107set_raw_breakpoint PARAMS ((struct symtab_and_line));
108
109static void
110check_duplicates PARAMS ((CORE_ADDR));
111
112static void
113describe_other_breakpoints PARAMS ((CORE_ADDR));
114
30875e1c
SG
115static void
116breakpoints_info PARAMS ((char *, int));
117
118static void
423e9664 119breakpoint_1 PARAMS ((int, int));
30875e1c
SG
120
121static bpstat
122bpstat_alloc PARAMS ((struct breakpoint *, bpstat));
123
124static int
125breakpoint_cond_eval PARAMS ((char *));
126
127static void
128cleanup_executing_breakpoints PARAMS ((int));
129
130static void
131commands_command PARAMS ((char *, int));
132
133static void
134condition_command PARAMS ((char *, int));
135
136static int
137get_number PARAMS ((char **));
138
139static void
140set_breakpoint_count PARAMS ((int));
141
999dd04b
JL
142static int
143remove_breakpoint PARAMS ((struct breakpoint *));
30875e1c 144
bd5635a1 145extern int addressprint; /* Print machine addresses? */
bd5635a1 146
bd5635a1
RP
147/* Are we executing breakpoint commands? */
148static int executing_breakpoint_commands;
149
cba0d141
JG
150/* Walk the following statement or block through all breakpoints.
151 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
152 breakpoint. */
153
bd5635a1
RP
154#define ALL_BREAKPOINTS(b) for (b = breakpoint_chain; b; b = b->next)
155
cba0d141
JG
156#define ALL_BREAKPOINTS_SAFE(b,tmp) \
157 for (b = breakpoint_chain; \
158 b? (tmp=b->next, 1): 0; \
159 b = tmp)
160
999dd04b
JL
161/* By default no support for hardware watchpoints is assumed. */
162#ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT
11054881
KH
163#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) 0
164#define target_remove_watchpoint(ADDR,LEN,TYPE) -1
165#define target_insert_watchpoint(ADDR,LEN,TYPE) -1
166#endif
167
168#ifndef target_insert_hw_breakpoint
169#define target_remove_hw_breakpoint(ADDR,SHADOW) -1
170#define target_insert_hw_breakpoint(ADDR,SHADOW) -1
171#endif
172
173#ifndef target_stopped_data_address
174#define target_stopped_data_address() 0
999dd04b
JL
175#endif
176
9f577285
SS
177/* True if breakpoint hit counts should be displayed in breakpoint info. */
178
179int show_breakpoint_hit_counts = 1;
180
bd5635a1
RP
181/* Chain of all breakpoints defined. */
182
05052b63 183static struct breakpoint *breakpoint_chain;
bd5635a1
RP
184
185/* Number of last breakpoint made. */
186
187static int breakpoint_count;
188
189/* Set breakpoint count to NUM. */
9f577285 190
bd5635a1
RP
191static void
192set_breakpoint_count (num)
193 int num;
194{
195 breakpoint_count = num;
196 set_internalvar (lookup_internalvar ("bpnum"),
06b6c733 197 value_from_longest (builtin_type_int, (LONGEST) num));
bd5635a1
RP
198}
199
9f577285
SS
200/* Used in run_command to zero the hit count when a new run starts. */
201
202void
203clear_breakpoint_hit_counts ()
204{
205 struct breakpoint *b;
206
207 ALL_BREAKPOINTS (b)
208 b->hit_count = 0;
209}
210
bd5635a1
RP
211/* Default address, symtab and line to put a breakpoint at
212 for "break" command with no arg.
213 if default_breakpoint_valid is zero, the other three are
214 not valid, and "break" with no arg is an error.
215
216 This set by print_stack_frame, which calls set_default_breakpoint. */
217
218int default_breakpoint_valid;
219CORE_ADDR default_breakpoint_address;
220struct symtab *default_breakpoint_symtab;
221int default_breakpoint_line;
bd5635a1
RP
222\f
223/* *PP is a string denoting a breakpoint. Get the number of the breakpoint.
224 Advance *PP after the string and any trailing whitespace.
225
226 Currently the string can either be a number or "$" followed by the name
227 of a convenience variable. Making it an expression wouldn't work well
228 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). */
229static int
230get_number (pp)
231 char **pp;
232{
233 int retval;
234 char *p = *pp;
235
236 if (p == NULL)
237 /* Empty line means refer to the last breakpoint. */
238 return breakpoint_count;
239 else if (*p == '$')
240 {
241 /* Make a copy of the name, so we can null-terminate it
242 to pass to lookup_internalvar(). */
243 char *varname;
244 char *start = ++p;
82a2edfb 245 value_ptr val;
bd5635a1
RP
246
247 while (isalnum (*p) || *p == '_')
248 p++;
249 varname = (char *) alloca (p - start + 1);
250 strncpy (varname, start, p - start);
251 varname[p - start] = '\0';
252 val = value_of_internalvar (lookup_internalvar (varname));
253 if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_INT)
254 error (
255"Convenience variables used to specify breakpoints must have integer values."
256 );
257 retval = (int) value_as_long (val);
258 }
259 else
260 {
80ba48f5
SG
261 if (*p == '-')
262 ++p;
bd5635a1
RP
263 while (*p >= '0' && *p <= '9')
264 ++p;
265 if (p == *pp)
266 /* There is no number here. (e.g. "cond a == b"). */
267 error_no_arg ("breakpoint number");
268 retval = atoi (*pp);
269 }
270 if (!(isspace (*p) || *p == '\0'))
271 error ("breakpoint number expected");
272 while (isspace (*p))
273 p++;
274 *pp = p;
275 return retval;
276}
277\f
278/* condition N EXP -- set break condition of breakpoint N to EXP. */
279
280static void
281condition_command (arg, from_tty)
282 char *arg;
283 int from_tty;
284{
285 register struct breakpoint *b;
286 char *p;
287 register int bnum;
288
289 if (arg == 0)
290 error_no_arg ("breakpoint number");
291
292 p = arg;
293 bnum = get_number (&p);
294
295 ALL_BREAKPOINTS (b)
296 if (b->number == bnum)
297 {
298 if (b->cond)
299 {
c8950965 300 free ((PTR)b->cond);
bd5635a1
RP
301 b->cond = 0;
302 }
303 if (b->cond_string != NULL)
c8950965 304 free ((PTR)b->cond_string);
bd5635a1
RP
305
306 if (*p == 0)
307 {
308 b->cond = 0;
309 b->cond_string = NULL;
310 if (from_tty)
423e9664 311 printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
bd5635a1
RP
312 }
313 else
314 {
315 arg = p;
316 /* I don't know if it matters whether this is the string the user
317 typed in or the decompiled expression. */
318 b->cond_string = savestring (arg, strlen (arg));
d3b9c0df 319 b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
bd5635a1
RP
320 if (*arg)
321 error ("Junk at end of expression");
322 }
16726dd1 323 breakpoints_changed ();
bd5635a1
RP
324 return;
325 }
326
327 error ("No breakpoint number %d.", bnum);
328}
329
bdbd5f50 330/* ARGSUSED */
bd5635a1
RP
331static void
332commands_command (arg, from_tty)
333 char *arg;
334 int from_tty;
335{
336 register struct breakpoint *b;
337 char *p;
338 register int bnum;
339 struct command_line *l;
340
341 /* If we allowed this, we would have problems with when to
342 free the storage, if we change the commands currently
343 being read from. */
344
345 if (executing_breakpoint_commands)
346 error ("Can't use the \"commands\" command among a breakpoint's commands.");
347
348 p = arg;
349 bnum = get_number (&p);
350 if (p && *p)
351 error ("Unexpected extra arguments following breakpoint number.");
352
353 ALL_BREAKPOINTS (b)
354 if (b->number == bnum)
355 {
bdbd5f50 356 if (from_tty && input_from_terminal_p ())
9b280a7f 357 printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
bd5635a1 358End with a line saying just \"end\".\n", bnum);
bd5635a1
RP
359 l = read_command_lines ();
360 free_command_lines (&b->commands);
361 b->commands = l;
6c803036 362 breakpoints_changed ();
bd5635a1
RP
363 return;
364 }
365 error ("No breakpoint number %d.", bnum);
366}
367\f
31ef19fc
JK
368extern int memory_breakpoint_size; /* from mem-break.c */
369
370/* Like target_read_memory() but if breakpoints are inserted, return
30875e1c
SG
371 the shadow contents instead of the breakpoints themselves.
372
373 Read "memory data" from whatever target or inferior we have.
374 Returns zero if successful, errno value if not. EIO is used
375 for address out of bounds. If breakpoints are inserted, returns
376 shadow contents, not the breakpoints themselves. From breakpoint.c. */
377
31ef19fc
JK
378int
379read_memory_nobpt (memaddr, myaddr, len)
380 CORE_ADDR memaddr;
381 char *myaddr;
382 unsigned len;
383{
384 int status;
385 struct breakpoint *b;
386
387 if (memory_breakpoint_size < 0)
5af4f5f6
JK
388 /* No breakpoints on this machine. FIXME: This should be
389 dependent on the debugging target. Probably want
390 target_insert_breakpoint to return a size, saying how many
391 bytes of the shadow contents are used, or perhaps have
392 something like target_xfer_shadow. */
31ef19fc
JK
393 return target_read_memory (memaddr, myaddr, len);
394
395 ALL_BREAKPOINTS (b)
396 {
999dd04b
JL
397 if (b->type == bp_watchpoint
398 || b->type == bp_hardware_watchpoint
11054881
KH
399 || b->type == bp_read_watchpoint
400 || b->type == bp_access_watchpoint
999dd04b 401 || !b->inserted)
31ef19fc
JK
402 continue;
403 else if (b->address + memory_breakpoint_size <= memaddr)
404 /* The breakpoint is entirely before the chunk of memory
405 we are reading. */
406 continue;
407 else if (b->address >= memaddr + len)
408 /* The breakpoint is entirely after the chunk of memory we
409 are reading. */
410 continue;
411 else
412 {
413 /* Copy the breakpoint from the shadow contents, and recurse
414 for the things before and after. */
415
416 /* Addresses and length of the part of the breakpoint that
417 we need to copy. */
418 CORE_ADDR membpt = b->address;
419 unsigned int bptlen = memory_breakpoint_size;
420 /* Offset within shadow_contents. */
421 int bptoffset = 0;
422
423 if (membpt < memaddr)
424 {
425 /* Only copy the second part of the breakpoint. */
426 bptlen -= memaddr - membpt;
427 bptoffset = memaddr - membpt;
428 membpt = memaddr;
429 }
430
431 if (membpt + bptlen > memaddr + len)
432 {
433 /* Only copy the first part of the breakpoint. */
434 bptlen -= (membpt + bptlen) - (memaddr + len);
435 }
436
4ed3a9ea
FF
437 memcpy (myaddr + membpt - memaddr,
438 b->shadow_contents + bptoffset, bptlen);
31ef19fc
JK
439
440 if (membpt > memaddr)
441 {
442 /* Copy the section of memory before the breakpoint. */
443 status = read_memory_nobpt (memaddr, myaddr, membpt - memaddr);
444 if (status != 0)
445 return status;
446 }
447
448 if (membpt + bptlen < memaddr + len)
449 {
450 /* Copy the section of memory after the breakpoint. */
451 status = read_memory_nobpt
452 (membpt + bptlen,
453 myaddr + membpt + bptlen - memaddr,
454 memaddr + len - (membpt + bptlen));
455 if (status != 0)
456 return status;
457 }
458 return 0;
459 }
460 }
461 /* Nothing overlaps. Just call read_memory_noerr. */
462 return target_read_memory (memaddr, myaddr, len);
463}
464\f
bd5635a1
RP
465/* insert_breakpoints is used when starting or continuing the program.
466 remove_breakpoints is used when the program stops.
467 Both return zero if successful,
468 or an `errno' value if could not write the inferior. */
469
470int
471insert_breakpoints ()
472{
473 register struct breakpoint *b;
474 int val = 0;
475 int disabled_breaks = 0;
476
477 ALL_BREAKPOINTS (b)
30875e1c 478 if (b->type != bp_watchpoint
999dd04b 479 && b->type != bp_hardware_watchpoint
11054881
KH
480 && b->type != bp_read_watchpoint
481 && b->type != bp_access_watchpoint
bd5635a1
RP
482 && b->enable != disabled
483 && ! b->inserted
484 && ! b->duplicate)
485 {
11054881
KH
486 if (b->type == bp_hardware_breakpoint)
487 val = target_insert_hw_breakpoint(b->address, b->shadow_contents);
488 else
489 val = target_insert_breakpoint(b->address, b->shadow_contents);
bd5635a1
RP
490 if (val)
491 {
492 /* Can't set the breakpoint. */
493#if defined (DISABLE_UNSETTABLE_BREAK)
494 if (DISABLE_UNSETTABLE_BREAK (b->address))
495 {
496 val = 0;
497 b->enable = disabled;
498 if (!disabled_breaks)
499 {
05052b63 500 target_terminal_ours_for_output ();
199b2450 501 fprintf_unfiltered (gdb_stderr,
2d313932 502 "Cannot insert breakpoint %d:\n", b->number);
bd5635a1
RP
503 printf_filtered ("Disabling shared library breakpoints:\n");
504 }
505 disabled_breaks = 1;
506 printf_filtered ("%d ", b->number);
507 }
508 else
509#endif
510 {
05052b63 511 target_terminal_ours_for_output ();
199b2450 512 fprintf_unfiltered (gdb_stderr, "Cannot insert breakpoint %d:\n", b->number);
d3b9c0df 513#ifdef ONE_PROCESS_WRITETEXT
199b2450 514 fprintf_unfiltered (gdb_stderr,
2d313932 515 "The same program may be running in another process.\n");
d3b9c0df 516#endif
bd5635a1
RP
517 memory_error (val, b->address); /* which bombs us out */
518 }
519 }
520 else
521 b->inserted = 1;
522 }
11054881
KH
523 else if ((b->type == bp_hardware_watchpoint ||
524 b->type == bp_read_watchpoint ||
525 b->type == bp_access_watchpoint)
999dd04b
JL
526 && b->enable == enabled
527 && ! b->inserted
528 && ! b->duplicate)
529 {
706dc3ce 530 struct frame_info *saved_frame;
999dd04b
JL
531 int saved_level, within_current_scope;
532 value_ptr mark = value_mark ();
533 value_ptr v;
534
535 /* Save the current frame and level so we can restore it after
536 evaluating the watchpoint expression on its own frame. */
537 saved_frame = selected_frame;
538 saved_level = selected_frame_level;
539
540 /* Determine if the watchpoint is within scope. */
541 if (b->exp_valid_block == NULL)
542 within_current_scope = 1;
543 else
544 {
706dc3ce
JL
545 struct frame_info *fi =
546 find_frame_addr_in_frame_chain (b->watchpoint_frame);
547 within_current_scope = (fi != NULL);
999dd04b 548 if (within_current_scope)
706dc3ce 549 select_frame (fi, -1);
999dd04b
JL
550 }
551
552 if (within_current_scope)
553 {
554 /* Evaluate the expression and cut the chain of values
555 produced off from the value chain. */
556 v = evaluate_expression (b->exp);
557 value_release_to_mark (mark);
558
559 b->val_chain = v;
560 b->inserted = 1;
561
562 /* Look at each value on the value chain. */
563 for ( ; v; v=v->next)
564 {
565 /* If it's a memory location, then we must watch it. */
566 if (v->lval == lval_memory)
567 {
11054881 568 int addr, len, type;
999dd04b
JL
569
570 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
571 len = TYPE_LENGTH (VALUE_TYPE (v));
11054881
KH
572 type = 0;
573 if (b->type == bp_read_watchpoint)
574 type = 1;
575 else if (b->type == bp_access_watchpoint)
576 type = 2;
577
578 val = target_insert_watchpoint (addr, len, type);
999dd04b
JL
579 if (val == -1)
580 {
581 b->inserted = 0;
582 break;
583 }
584 val = 0;
585 }
586 }
587 /* Failure to insert a watchpoint on any memory value in the
588 value chain brings us here. */
589 if (!b->inserted)
590 warning ("Hardware watchpoint %d: Could not insert watchpoint\n",
591 b->number);
592 }
593 else
594 {
595 printf_filtered ("\
596Hardware watchpoint %d deleted because the program has left the block in\n\
597which its expression is valid.\n", b->number);
598 if (b->related_breakpoint)
599 delete_breakpoint (b->related_breakpoint);
600 delete_breakpoint (b);
601 }
602
603 /* Restore the frame and level. */
604 select_frame (saved_frame, saved_level);
605 }
bd5635a1
RP
606 if (disabled_breaks)
607 printf_filtered ("\n");
608 return val;
609}
610
999dd04b 611
bd5635a1
RP
612int
613remove_breakpoints ()
614{
615 register struct breakpoint *b;
616 int val;
617
bd5635a1 618 ALL_BREAKPOINTS (b)
999dd04b
JL
619 {
620 if (b->inserted)
621 {
622 val = remove_breakpoint (b);
623 if (val != 0)
624 return val;
625 }
626 }
627 return 0;
628}
bd5635a1 629
999dd04b
JL
630
631static int
632remove_breakpoint (b)
633 struct breakpoint *b;
634{
635 int val;
636
637 if (b->type != bp_watchpoint
11054881
KH
638 && b->type != bp_hardware_watchpoint
639 && b->type != bp_read_watchpoint
640 && b->type != bp_access_watchpoint)
999dd04b 641 {
11054881
KH
642 if (b->type == bp_hardware_breakpoint)
643 val = target_remove_hw_breakpoint(b->address, b->shadow_contents);
644 else
645 val = target_remove_breakpoint(b->address, b->shadow_contents);
999dd04b
JL
646 if (val)
647 return val;
648 b->inserted = 0;
649 }
11054881
KH
650 else if ((b->type == bp_hardware_watchpoint ||
651 b->type == bp_read_watchpoint ||
652 b->type == bp_access_watchpoint)
999dd04b
JL
653 && b->enable == enabled
654 && ! b->duplicate)
655 {
656 value_ptr v, n;
657
658 b->inserted = 0;
659 /* Walk down the saved value chain. */
660 for (v = b->val_chain; v; v = v->next)
661 {
662 /* For each memory reference remove the watchpoint
663 at that address. */
664 if (v->lval == lval_memory)
665 {
666 int addr, len;
667
668 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
669 len = TYPE_LENGTH (VALUE_TYPE (v));
11054881 670 val = target_remove_watchpoint (addr, len, b->type);
999dd04b
JL
671 if (val == -1)
672 b->inserted = 1;
673 val = 0;
674 }
675 }
676 /* Failure to remove any of the hardware watchpoints comes here. */
677 if (b->inserted)
678 error ("Hardware watchpoint %d: Could not remove watchpoint\n",
679 b->number);
680
681 /* Free the saved value chain. We will construct a new one
682 the next time the watchpoint is inserted. */
683 for (v = b->val_chain; v; v = n)
684 {
685 n = v->next;
686 value_free (v);
687 }
688 b->val_chain = NULL;
689 }
bd5635a1
RP
690 return 0;
691}
692
cf3e377e 693/* Clear the "inserted" flag in all breakpoints. */
bd5635a1
RP
694
695void
696mark_breakpoints_out ()
697{
698 register struct breakpoint *b;
699
700 ALL_BREAKPOINTS (b)
701 b->inserted = 0;
702}
703
cf3e377e
JK
704/* Clear the "inserted" flag in all breakpoints and delete any breakpoints
705 which should go away between runs of the program. */
706
707void
708breakpoint_init_inferior ()
709{
710 register struct breakpoint *b, *temp;
711
712 ALL_BREAKPOINTS_SAFE (b, temp)
713 {
714 b->inserted = 0;
715
716 /* If the call dummy breakpoint is at the entry point it will
717 cause problems when the inferior is rerun, so we better
718 get rid of it. */
719 if (b->type == bp_call_dummy)
720 delete_breakpoint (b);
999dd04b
JL
721
722 /* Likewise for scope breakpoints. */
723 if (b->type == bp_watchpoint_scope)
724 delete_breakpoint (b);
725
726 /* Likewise for watchpoints on local expressions. */
11054881
KH
727 if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint ||
728 b->type == bp_read_watchpoint || b->type == bp_access_watchpoint)
999dd04b
JL
729 && b->exp_valid_block != NULL)
730 delete_breakpoint (b);
cf3e377e
JK
731 }
732}
733
bd5635a1
RP
734/* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
735 When continuing from a location with a breakpoint,
736 we actually single step once before calling insert_breakpoints. */
737
738int
739breakpoint_here_p (pc)
740 CORE_ADDR pc;
741{
742 register struct breakpoint *b;
743
744 ALL_BREAKPOINTS (b)
745 if (b->enable != disabled && b->address == pc)
746 return 1;
747
748 return 0;
749}
199b2450 750
05052b63
JK
751/* Return nonzero if FRAME is a dummy frame. We can't use PC_IN_CALL_DUMMY
752 because figuring out the saved SP would take too much time, at least using
753 get_saved_register on the 68k. This means that for this function to
754 work right a port must use the bp_call_dummy breakpoint. */
755
756int
757frame_in_dummy (frame)
706dc3ce 758 struct frame_info *frame;
05052b63
JK
759{
760 struct breakpoint *b;
761
d7e7e851 762#ifdef CALL_DUMMY
05052b63
JK
763 ALL_BREAKPOINTS (b)
764 {
d7e7e851
JK
765 static unsigned LONGEST dummy[] = CALL_DUMMY;
766
05052b63 767 if (b->type == bp_call_dummy
d7e7e851
JK
768 && b->frame == frame->frame
769
770 /* We need to check the PC as well as the frame on the sparc,
771 for signals.exp in the testsuite. */
772 && (frame->pc
773 >= (b->address
774 - sizeof (dummy) / sizeof (LONGEST) * REGISTER_SIZE))
775 && frame->pc <= b->address)
05052b63
JK
776 return 1;
777 }
d7e7e851 778#endif /* CALL_DUMMY */
05052b63
JK
779 return 0;
780}
781
199b2450
TL
782/* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
783 is valid for process/thread PID. */
784
785int
786breakpoint_thread_match (pc, pid)
787 CORE_ADDR pc;
788 int pid;
789{
790 struct breakpoint *b;
791 int thread;
792
793 thread = pid_to_thread_id (pid);
794
795 ALL_BREAKPOINTS (b)
796 if (b->enable != disabled
797 && b->address == pc
798 && (b->thread == -1 || b->thread == thread))
799 return 1;
800
801 return 0;
802}
803
bd5635a1
RP
804\f
805/* bpstat stuff. External routines' interfaces are documented
806 in breakpoint.h. */
30875e1c
SG
807
808/* Clear a bpstat so that it says we are not at any breakpoint.
809 Also free any storage that is part of a bpstat. */
810
bd5635a1
RP
811void
812bpstat_clear (bsp)
813 bpstat *bsp;
814{
815 bpstat p;
816 bpstat q;
817
818 if (bsp == 0)
819 return;
820 p = *bsp;
821 while (p != NULL)
822 {
823 q = p->next;
824 if (p->old_val != NULL)
825 value_free (p->old_val);
c8950965 826 free ((PTR)p);
bd5635a1
RP
827 p = q;
828 }
829 *bsp = NULL;
830}
831
30875e1c
SG
832/* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
833 is part of the bpstat is copied as well. */
834
bd5635a1
RP
835bpstat
836bpstat_copy (bs)
837 bpstat bs;
838{
839 bpstat p = NULL;
840 bpstat tmp;
fee933f1 841 bpstat retval = NULL;
bd5635a1
RP
842
843 if (bs == NULL)
844 return bs;
845
846 for (; bs != NULL; bs = bs->next)
847 {
848 tmp = (bpstat) xmalloc (sizeof (*tmp));
4ed3a9ea 849 memcpy (tmp, bs, sizeof (*tmp));
bd5635a1
RP
850 if (p == NULL)
851 /* This is the first thing in the chain. */
852 retval = tmp;
853 else
854 p->next = tmp;
855 p = tmp;
856 }
857 p->next = NULL;
858 return retval;
859}
860
30875e1c
SG
861/* Find the bpstat associated with this breakpoint */
862
863bpstat
864bpstat_find_breakpoint(bsp, breakpoint)
865 bpstat bsp;
866 struct breakpoint *breakpoint;
867{
868 if (bsp == NULL) return NULL;
869
870 for (;bsp != NULL; bsp = bsp->next) {
871 if (bsp->breakpoint_at == breakpoint) return bsp;
872 }
873 return NULL;
874}
875
876/* Return the breakpoint number of the first breakpoint we are stopped
877 at. *BSP upon return is a bpstat which points to the remaining
878 breakpoints stopped at (but which is not guaranteed to be good for
879 anything but further calls to bpstat_num).
880 Return 0 if passed a bpstat which does not indicate any breakpoints. */
881
bd5635a1
RP
882int
883bpstat_num (bsp)
884 bpstat *bsp;
885{
886 struct breakpoint *b;
887
888 if ((*bsp) == NULL)
889 return 0; /* No more breakpoint values */
890 else
891 {
892 b = (*bsp)->breakpoint_at;
893 *bsp = (*bsp)->next;
894 if (b == NULL)
895 return -1; /* breakpoint that's been deleted since */
896 else
897 return b->number; /* We have its number */
898 }
899}
900
30875e1c
SG
901/* Modify BS so that the actions will not be performed. */
902
bd5635a1
RP
903void
904bpstat_clear_actions (bs)
905 bpstat bs;
906{
907 for (; bs != NULL; bs = bs->next)
908 {
909 bs->commands = NULL;
910 if (bs->old_val != NULL)
911 {
912 value_free (bs->old_val);
913 bs->old_val = NULL;
914 }
915 }
916}
917
bdbd5f50
JG
918/* Stub for cleaning up our state if we error-out of a breakpoint command */
919/* ARGSUSED */
920static void
921cleanup_executing_breakpoints (ignore)
922 int ignore;
923{
924 executing_breakpoint_commands = 0;
925}
926
bd5635a1
RP
927/* Execute all the commands associated with all the breakpoints at this
928 location. Any of these commands could cause the process to proceed
929 beyond this point, etc. We look out for such changes by checking
930 the global "breakpoint_proceeded" after each command. */
30875e1c 931
bd5635a1
RP
932void
933bpstat_do_actions (bsp)
934 bpstat *bsp;
935{
936 bpstat bs;
bdbd5f50
JG
937 struct cleanup *old_chain;
938
939 executing_breakpoint_commands = 1;
940 old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
bd5635a1
RP
941
942top:
943 bs = *bsp;
944
bd5635a1
RP
945 breakpoint_proceeded = 0;
946 for (; bs != NULL; bs = bs->next)
947 {
948 while (bs->commands)
949 {
950 char *line = bs->commands->line;
951 bs->commands = bs->commands->next;
952 execute_command (line, 0);
953 /* If the inferior is proceeded by the command, bomb out now.
954 The bpstat chain has been blown away by wait_for_inferior.
955 But since execution has stopped again, there is a new bpstat
956 to look at, so start over. */
957 if (breakpoint_proceeded)
958 goto top;
959 }
960 }
bd5635a1
RP
961
962 executing_breakpoint_commands = 0;
bdbd5f50 963 discard_cleanups (old_chain);
bd5635a1
RP
964}
965
8af68e4e
JK
966/* This is the normal print_it function for a bpstat. In the future,
967 much of this logic could (should?) be moved to bpstat_stop_status,
968 by having it set different print_it functions. */
30875e1c 969
8af68e4e
JK
970static int
971print_it_normal (bs)
bd5635a1
RP
972 bpstat bs;
973{
974 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
975 which has since been deleted. */
8af68e4e 976 if (bs->breakpoint_at == NULL
30875e1c 977 || (bs->breakpoint_at->type != bp_breakpoint
11054881 978 && bs->breakpoint_at->type != bp_hardware_breakpoint
999dd04b 979 && bs->breakpoint_at->type != bp_watchpoint
11054881
KH
980 && bs->breakpoint_at->type != bp_read_watchpoint
981 && bs->breakpoint_at->type != bp_access_watchpoint
999dd04b 982 && bs->breakpoint_at->type != bp_hardware_watchpoint))
bd5635a1 983 return 0;
bd5635a1 984
11054881
KH
985 if (bs->breakpoint_at->type == bp_breakpoint ||
986 bs->breakpoint_at->type == bp_hardware_breakpoint)
bd5635a1
RP
987 {
988 /* I think the user probably only wants to see one breakpoint
989 number, not all of them. */
f2d9c058 990 annotate_breakpoint (bs->breakpoint_at->number);
bd5635a1
RP
991 printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
992 return 0;
993 }
11054881
KH
994 else if ((bs->old_val != NULL) &&
995 (bs->breakpoint_at->type == bp_watchpoint ||
996 bs->breakpoint_at->type == bp_access_watchpoint ||
997 bs->breakpoint_at->type == bp_hardware_watchpoint))
bd5635a1 998 {
f2d9c058 999 annotate_watchpoint (bs->breakpoint_at->number);
11054881 1000 mention (bs->breakpoint_at);
bd5635a1 1001 printf_filtered ("\nOld value = ");
199b2450 1002 value_print (bs->old_val, gdb_stdout, 0, Val_pretty_default);
bd5635a1 1003 printf_filtered ("\nNew value = ");
199b2450 1004 value_print (bs->breakpoint_at->val, gdb_stdout, 0,
bd5635a1
RP
1005 Val_pretty_default);
1006 printf_filtered ("\n");
1007 value_free (bs->old_val);
1008 bs->old_val = NULL;
bd2f0c85
JL
1009 /* More than one watchpoint may have been triggered. */
1010 return -1;
bd5635a1 1011 }
11054881
KH
1012 else if (bs->breakpoint_at->type == bp_access_watchpoint ||
1013 bs->breakpoint_at->type == bp_read_watchpoint)
1014 {
1015 mention (bs->breakpoint_at);
1016 printf_filtered ("\nValue = ");
1017 value_print (bs->breakpoint_at->val, gdb_stdout, 0,
1018 Val_pretty_default);
1019 printf_filtered ("\n");
1020 return -1;
1021 }
8af68e4e
JK
1022 /* We can't deal with it. Maybe another member of the bpstat chain can. */
1023 return -1;
1024}
1025
1026/* Print a message indicating what happened. Returns nonzero to
1027 say that only the source line should be printed after this (zero
1028 return means print the frame as well as the source line). */
3f031adf 1029/* Currently we always return zero. */
8af68e4e
JK
1030int
1031bpstat_print (bs)
1032 bpstat bs;
1033{
1034 int val;
1035
1036 if (bs == NULL)
1037 return 0;
bd5635a1 1038
8af68e4e
JK
1039 val = (*bs->print_it) (bs);
1040 if (val >= 0)
1041 return val;
1042
fcb887ff
JK
1043 /* Maybe another breakpoint in the chain caused us to stop.
1044 (Currently all watchpoints go on the bpstat whether hit or
1045 not. That probably could (should) be changed, provided care is taken
1046 with respect to bpstat_explains_signal). */
1047 if (bs->next)
1048 return bpstat_print (bs->next);
1049
cabd4da6 1050 /* We reached the end of the chain without printing anything. */
bd5635a1
RP
1051 return 0;
1052}
1053
1054/* Evaluate the expression EXP and return 1 if value is zero.
1055 This is used inside a catch_errors to evaluate the breakpoint condition.
bdbd5f50 1056 The argument is a "struct expression *" that has been cast to char * to
bd5635a1
RP
1057 make it pass through catch_errors. */
1058
1059static int
1060breakpoint_cond_eval (exp)
bdbd5f50 1061 char *exp;
bd5635a1 1062{
11054881
KH
1063 value_ptr mark = value_mark ();
1064 int i = !value_true (evaluate_expression ((struct expression *)exp));
1065 value_free_to_mark (mark);
1066 return i;
bd5635a1
RP
1067}
1068
1069/* Allocate a new bpstat and chain it to the current one. */
1070
1071static bpstat
1072bpstat_alloc (b, cbs)
1073 register struct breakpoint *b;
1074 bpstat cbs; /* Current "bs" value */
1075{
1076 bpstat bs;
1077
1078 bs = (bpstat) xmalloc (sizeof (*bs));
1079 cbs->next = bs;
1080 bs->breakpoint_at = b;
1081 /* If the condition is false, etc., don't do the commands. */
1082 bs->commands = NULL;
bd5635a1 1083 bs->old_val = NULL;
8af68e4e 1084 bs->print_it = print_it_normal;
bd5635a1
RP
1085 return bs;
1086}
fa99ebe1 1087\f
8af68e4e
JK
1088/* Possible return values for watchpoint_check (this can't be an enum
1089 because of check_errors). */
999dd04b
JL
1090/* The watchpoint has been deleted. */
1091#define WP_DELETED 1
8af68e4e
JK
1092/* The value has changed. */
1093#define WP_VALUE_CHANGED 2
1094/* The value has not changed. */
1095#define WP_VALUE_NOT_CHANGED 3
1096
1097/* Check watchpoint condition. */
557f3a0e 1098
8af68e4e
JK
1099static int
1100watchpoint_check (p)
fe675038 1101 char *p;
8af68e4e
JK
1102{
1103 bpstat bs = (bpstat) p;
11054881 1104 struct breakpoint *b;
706dc3ce 1105 struct frame_info *saved_frame, *fr;
999dd04b
JL
1106 int within_current_scope, saved_level;
1107
557f3a0e
SS
1108 b = bs->breakpoint_at;
1109
1110 if (b->exp_valid_block == NULL)
8af68e4e 1111 within_current_scope = 1;
fa99ebe1
JK
1112 else
1113 {
706dc3ce
JL
1114 /* There is no current frame at this moment. If we're going to have
1115 any chance of handling watchpoints on local variables, we'll need
1116 the frame chain (so we can determine if we're in scope). */
1117 reinit_frame_cache();
557f3a0e 1118 fr = find_frame_addr_in_frame_chain (b->watchpoint_frame);
999dd04b 1119 within_current_scope = (fr != NULL);
fa99ebe1
JK
1120 if (within_current_scope)
1121 /* If we end up stopping, the current frame will get selected
1122 in normal_stop. So this call to select_frame won't affect
1123 the user. */
1124 select_frame (fr, -1);
1125 }
1126
8af68e4e
JK
1127 if (within_current_scope)
1128 {
1129 /* We use value_{,free_to_}mark because it could be a
1130 *long* time before we return to the command level and
cef4c2e7
PS
1131 call free_all_values. We can't call free_all_values because
1132 we might be in the middle of evaluating a function call. */
8af68e4e 1133
82a2edfb
JK
1134 value_ptr mark = value_mark ();
1135 value_ptr new_val = evaluate_expression (bs->breakpoint_at->exp);
557f3a0e 1136 if (!value_equal (b->val, new_val))
8af68e4e
JK
1137 {
1138 release_value (new_val);
1139 value_free_to_mark (mark);
557f3a0e
SS
1140 bs->old_val = b->val;
1141 b->val = new_val;
8af68e4e
JK
1142 /* We will stop here */
1143 return WP_VALUE_CHANGED;
1144 }
1145 else
1146 {
1147 /* Nothing changed, don't do anything. */
1148 value_free_to_mark (mark);
1149 /* We won't stop here */
1150 return WP_VALUE_NOT_CHANGED;
1151 }
1152 }
1153 else
1154 {
1155 /* This seems like the only logical thing to do because
1156 if we temporarily ignored the watchpoint, then when
1157 we reenter the block in which it is valid it contains
1158 garbage (in the case of a function, it may have two
1159 garbage values, one before and one after the prologue).
1160 So we can't even detect the first assignment to it and
1161 watch after that (since the garbage may or may not equal
1162 the first value assigned). */
8af68e4e 1163 printf_filtered ("\
999dd04b 1164Watchpoint %d deleted because the program has left the block in\n\
8af68e4e 1165which its expression is valid.\n", bs->breakpoint_at->number);
557f3a0e
SS
1166 if (b->related_breakpoint)
1167 delete_breakpoint (b->related_breakpoint);
1168 delete_breakpoint (b);
999dd04b 1169
999dd04b 1170 return WP_DELETED;
8af68e4e
JK
1171 }
1172}
1173
1174/* This is used when everything which needs to be printed has
1175 already been printed. But we still want to print the frame. */
1176static int
cabd4da6 1177print_it_done (bs)
8af68e4e
JK
1178 bpstat bs;
1179{
1180 return 0;
1181}
1182
cabd4da6
JK
1183/* This is used when nothing should be printed for this bpstat entry. */
1184
1185static int
1186print_it_noop (bs)
1187 bpstat bs;
1188{
1189 return -1;
1190}
1191
cb6b0202 1192/* Get a bpstat associated with having just stopped at address *PC
706dc3ce 1193 and frame address CORE_ADDRESS. Update *PC to point at the
cb6b0202
JK
1194 breakpoint (if we hit a breakpoint). NOT_A_BREAKPOINT is nonzero
1195 if this is known to not be a real breakpoint (it could still be a
1196 watchpoint, though). */
1197
bd5635a1
RP
1198/* Determine whether we stopped at a breakpoint, etc, or whether we
1199 don't understand this stop. Result is a chain of bpstat's such that:
1200
1201 if we don't understand the stop, the result is a null pointer.
1202
cb6b0202 1203 if we understand why we stopped, the result is not null.
bd5635a1
RP
1204
1205 Each element of the chain refers to a particular breakpoint or
1206 watchpoint at which we have stopped. (We may have stopped for
2d313932 1207 several reasons concurrently.)
bd5635a1
RP
1208
1209 Each element of the chain has valid next, breakpoint_at,
1210 commands, FIXME??? fields.
1211
1212 */
1213
bd5635a1 1214bpstat
16726dd1 1215bpstat_stop_status (pc, not_a_breakpoint)
bd5635a1 1216 CORE_ADDR *pc;
cb6b0202 1217 int not_a_breakpoint;
bd5635a1
RP
1218{
1219 register struct breakpoint *b;
bd5635a1 1220 CORE_ADDR bp_addr;
bdbd5f50 1221#if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
bd5635a1
RP
1222 /* True if we've hit a breakpoint (as opposed to a watchpoint). */
1223 int real_breakpoint = 0;
bdbd5f50 1224#endif
bd5635a1 1225 /* Root of the chain of bpstat's */
cba0d141 1226 struct bpstat root_bs[1];
bd5635a1
RP
1227 /* Pointer to the last thing in the chain currently. */
1228 bpstat bs = root_bs;
11054881
KH
1229 static char message1[] =
1230 "Error evaluating expression for watchpoint %d\n";
1231 char message[sizeof (message1) + 30 /* slop */];
bd5635a1
RP
1232
1233 /* Get the address where the breakpoint would have been. */
1234 bp_addr = *pc - DECR_PC_AFTER_BREAK;
1235
1236 ALL_BREAKPOINTS (b)
1237 {
bd5635a1
RP
1238 if (b->enable == disabled)
1239 continue;
30875e1c 1240
999dd04b
JL
1241 if (b->type != bp_watchpoint
1242 && b->type != bp_hardware_watchpoint
11054881
KH
1243 && b->type != bp_read_watchpoint
1244 && b->type != bp_access_watchpoint
1245 && b->type != bp_hardware_breakpoint
999dd04b 1246 && b->address != bp_addr)
bd5635a1
RP
1247 continue;
1248
11054881
KH
1249#ifndef DECR_PC_AFTER_HW_BREAK
1250#define DECR_PC_AFTER_HW_BREAK 0
1251#endif
1252 if (b->type == bp_hardware_breakpoint
1253 && b->address != (bp_addr - DECR_PC_AFTER_HW_BREAK))
1254 continue;
1255
999dd04b
JL
1256 if (b->type != bp_watchpoint
1257 && b->type != bp_hardware_watchpoint
11054881
KH
1258 && b->type != bp_read_watchpoint
1259 && b->type != bp_access_watchpoint
999dd04b 1260 && not_a_breakpoint)
cb6b0202
JK
1261 continue;
1262
30875e1c
SG
1263 /* Come here if it's a watchpoint, or if the break address matches */
1264
9f577285
SS
1265 ++(b->hit_count);
1266
bd5635a1
RP
1267 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */
1268
cabd4da6
JK
1269 bs->stop = 1;
1270 bs->print = 1;
bd5635a1 1271
11054881 1272 sprintf (message, message1, b->number);
999dd04b 1273 if (b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
bd5635a1 1274 {
fe675038
JK
1275 switch (catch_errors (watchpoint_check, (char *) bs, message,
1276 RETURN_MASK_ALL))
bd5635a1 1277 {
999dd04b 1278 case WP_DELETED:
8af68e4e 1279 /* We've already printed what needs to be printed. */
cabd4da6 1280 bs->print_it = print_it_done;
8af68e4e
JK
1281 /* Stop. */
1282 break;
1283 case WP_VALUE_CHANGED:
1284 /* Stop. */
1285 break;
1286 case WP_VALUE_NOT_CHANGED:
1287 /* Don't stop. */
cabd4da6
JK
1288 bs->print_it = print_it_noop;
1289 bs->stop = 0;
bd5635a1 1290 continue;
8af68e4e
JK
1291 default:
1292 /* Can't happen. */
1293 /* FALLTHROUGH */
1294 case 0:
1295 /* Error from catch_errors. */
999dd04b
JL
1296 printf_filtered ("Watchpoint %d deleted.\n", b->number);
1297 if (b->related_breakpoint)
1298 delete_breakpoint (b->related_breakpoint);
1299 delete_breakpoint (b);
8af68e4e 1300 /* We've already printed what needs to be printed. */
cabd4da6 1301 bs->print_it = print_it_done;
999dd04b 1302
8af68e4e
JK
1303 /* Stop. */
1304 break;
bd5635a1
RP
1305 }
1306 }
11054881
KH
1307 else if (b->type == bp_read_watchpoint || b->type == bp_access_watchpoint)
1308 {
1309 CORE_ADDR addr;
1310 value_ptr v;
1311 int found = 0;
1312
1313 addr = target_stopped_data_address();
1314 if (addr == 0) continue;
1315 for (v = b->val_chain; v; v = v->next)
1316 {
1317 if (v->lval == lval_memory)
1318 {
1319 CORE_ADDR vaddr;
1320
1321 vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
1322 if (addr == vaddr)
1323 found = 1;
1324 }
1325 }
1326 if (found)
1327 switch (catch_errors (watchpoint_check, (char *) bs, message,
1328 RETURN_MASK_ALL))
1329 {
1330 case WP_DELETED:
1331 /* We've already printed what needs to be printed. */
1332 bs->print_it = print_it_done;
1333 /* Stop. */
1334 break;
1335 case WP_VALUE_CHANGED:
1336 case WP_VALUE_NOT_CHANGED:
1337 /* Stop. */
1338 break;
1339 default:
1340 /* Can't happen. */
1341 case 0:
1342 /* Error from catch_errors. */
1343 printf_filtered ("Watchpoint %d deleted.\n", b->number);
1344 if (b->related_breakpoint)
1345 delete_breakpoint (b->related_breakpoint);
1346 delete_breakpoint (b);
1347 /* We've already printed what needs to be printed. */
1348 bs->print_it = print_it_done;
1349 break;
1350 }
1351 }
bdbd5f50 1352#if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
bd5635a1
RP
1353 else
1354 real_breakpoint = 1;
bdbd5f50 1355#endif
bd5635a1 1356
706dc3ce 1357 if (b->frame && b->frame != (get_current_frame ())->frame)
cabd4da6 1358 bs->stop = 0;
bd5635a1
RP
1359 else
1360 {
fee933f1 1361 int value_is_zero = 0;
bd5635a1
RP
1362
1363 if (b->cond)
1364 {
1365 /* Need to select the frame, with all that implies
1366 so that the conditions will have the right context. */
1367 select_frame (get_current_frame (), 0);
bdbd5f50
JG
1368 value_is_zero
1369 = catch_errors (breakpoint_cond_eval, (char *)(b->cond),
fe675038
JK
1370 "Error in testing breakpoint condition:\n",
1371 RETURN_MASK_ALL);
06b6c733 1372 /* FIXME-someday, should give breakpoint # */
bd5635a1
RP
1373 free_all_values ();
1374 }
bdbd5f50 1375 if (b->cond && value_is_zero)
bd5635a1 1376 {
cabd4da6 1377 bs->stop = 0;
bd5635a1
RP
1378 }
1379 else if (b->ignore_count > 0)
1380 {
1381 b->ignore_count--;
cabd4da6 1382 bs->stop = 0;
bd5635a1
RP
1383 }
1384 else
1385 {
1386 /* We will stop here */
30875e1c 1387 if (b->disposition == disable)
bd5635a1
RP
1388 b->enable = disabled;
1389 bs->commands = b->commands;
1390 if (b->silent)
cabd4da6 1391 bs->print = 0;
2d313932 1392 if (bs->commands && STREQ ("silent", bs->commands->line))
bd5635a1
RP
1393 {
1394 bs->commands = bs->commands->next;
cabd4da6 1395 bs->print = 0;
bd5635a1
RP
1396 }
1397 }
1398 }
cabd4da6
JK
1399 /* Print nothing for this entry if we dont stop or if we dont print. */
1400 if (bs->stop == 0 || bs->print == 0)
1401 bs->print_it = print_it_noop;
bd5635a1
RP
1402 }
1403
1404 bs->next = NULL; /* Terminate the chain */
1405 bs = root_bs->next; /* Re-grab the head of the chain */
cabd4da6 1406#if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
bd5635a1
RP
1407 if (bs)
1408 {
bd5635a1
RP
1409 if (real_breakpoint)
1410 {
1411 *pc = bp_addr;
1412#if defined (SHIFT_INST_REGS)
817ac7f8 1413 SHIFT_INST_REGS();
bd5635a1
RP
1414#else /* No SHIFT_INST_REGS. */
1415 write_pc (bp_addr);
1416#endif /* No SHIFT_INST_REGS. */
1417 }
bd5635a1 1418 }
cabd4da6 1419#endif /* DECR_PC_AFTER_BREAK != 0. */
999dd04b
JL
1420
1421 /* The value of a hardware watchpoint hasn't changed, but the
1422 intermediate memory locations we are watching may have. */
11054881
KH
1423 if (bs && ! bs->stop &&
1424 (bs->breakpoint_at->type == bp_hardware_watchpoint ||
1425 bs->breakpoint_at->type == bp_read_watchpoint ||
1426 bs->breakpoint_at->type == bp_access_watchpoint))
999dd04b
JL
1427 {
1428 remove_breakpoints ();
1429 insert_breakpoints ();
1430 }
bd5635a1
RP
1431 return bs;
1432}
cabd4da6
JK
1433\f
1434/* Tell what to do about this bpstat. */
fe675038 1435struct bpstat_what
cabd4da6
JK
1436bpstat_what (bs)
1437 bpstat bs;
1438{
1439 /* Classify each bpstat as one of the following. */
1440 enum class {
fe675038
JK
1441 /* This bpstat element has no effect on the main_action. */
1442 no_effect = 0,
cabd4da6
JK
1443
1444 /* There was a watchpoint, stop but don't print. */
1445 wp_silent,
1446
1447 /* There was a watchpoint, stop and print. */
1448 wp_noisy,
1449
1450 /* There was a breakpoint but we're not stopping. */
1451 bp_nostop,
1452
1453 /* There was a breakpoint, stop but don't print. */
1454 bp_silent,
1455
1456 /* There was a breakpoint, stop and print. */
1457 bp_noisy,
1458
1459 /* We hit the longjmp breakpoint. */
1460 long_jump,
1461
1462 /* We hit the longjmp_resume breakpoint. */
1463 long_resume,
1464
d7e7e851
JK
1465 /* We hit the step_resume breakpoint. */
1466 step_resume,
1467
bcc37718
JK
1468 /* We hit the through_sigtramp breakpoint. */
1469 through_sig,
1470
cabd4da6
JK
1471 /* This is just used to count how many enums there are. */
1472 class_last
1473 };
1474
1475 /* Here is the table which drives this routine. So that we can
1476 format it pretty, we define some abbreviations for the
1477 enum bpstat_what codes. */
1478#define keep_c BPSTAT_WHAT_KEEP_CHECKING
1479#define stop_s BPSTAT_WHAT_STOP_SILENT
1480#define stop_n BPSTAT_WHAT_STOP_NOISY
1481#define single BPSTAT_WHAT_SINGLE
1482#define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1483#define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1484#define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
d7e7e851 1485#define sr BPSTAT_WHAT_STEP_RESUME
bcc37718 1486#define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
d7e7e851 1487
cabd4da6
JK
1488/* "Can't happen." Might want to print an error message.
1489 abort() is not out of the question, but chances are GDB is just
1490 a bit confused, not unusable. */
1491#define err BPSTAT_WHAT_STOP_NOISY
1492
1493 /* Given an old action and a class, come up with a new action. */
84d59861
JK
1494 /* One interesting property of this table is that wp_silent is the same
1495 as bp_silent and wp_noisy is the same as bp_noisy. That is because
1496 after stopping, the check for whether to step over a breakpoint
1497 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
1498 reference to how we stopped. We retain separate wp_silent and bp_silent
1499 codes in case we want to change that someday. */
d7e7e851
JK
1500
1501 /* step_resume entries: a step resume breakpoint overrides another
1502 breakpoint of signal handling (see comment in wait_for_inferior
1503 at first IN_SIGTRAMP where we set the step_resume breakpoint). */
bcc37718
JK
1504 /* We handle the through_sigtramp_breakpoint the same way; having both
1505 one of those and a step_resume_breakpoint is probably very rare (?). */
d7e7e851 1506
fe675038 1507 static const enum bpstat_what_main_action
cabd4da6
JK
1508 table[(int)class_last][(int)BPSTAT_WHAT_LAST] =
1509 {
1510 /* old action */
bcc37718
JK
1511 /* keep_c stop_s stop_n single setlr clrlr clrlrs sr ts
1512 */
1513/*no_effect*/ {keep_c,stop_s,stop_n,single, setlr , clrlr , clrlrs, sr, ts},
1514/*wp_silent*/ {stop_s,stop_s,stop_n,stop_s, stop_s, stop_s, stop_s, sr, ts},
1515/*wp_noisy*/ {stop_n,stop_n,stop_n,stop_n, stop_n, stop_n, stop_n, sr, ts},
1516/*bp_nostop*/ {single,stop_s,stop_n,single, setlr , clrlrs, clrlrs, sr, ts},
1517/*bp_silent*/ {stop_s,stop_s,stop_n,stop_s, stop_s, stop_s, stop_s, sr, ts},
1518/*bp_noisy*/ {stop_n,stop_n,stop_n,stop_n, stop_n, stop_n, stop_n, sr, ts},
1519/*long_jump*/ {setlr ,stop_s,stop_n,setlr , err , err , err , sr, ts},
1520/*long_resume*/ {clrlr ,stop_s,stop_n,clrlrs, err , err , err , sr, ts},
1521/*step_resume*/ {sr ,sr ,sr ,sr , sr , sr , sr , sr, ts},
1522/*through_sig*/ {ts ,ts ,ts ,ts , ts , ts , ts , ts, ts}
cabd4da6
JK
1523 };
1524#undef keep_c
1525#undef stop_s
1526#undef stop_n
1527#undef single
1528#undef setlr
1529#undef clrlr
1530#undef clrlrs
1531#undef err
bcc37718
JK
1532#undef sr
1533#undef ts
fe675038 1534 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
84d59861 1535 struct bpstat_what retval;
cabd4da6 1536
cef4c2e7 1537 retval.call_dummy = 0;
cabd4da6
JK
1538 for (; bs != NULL; bs = bs->next)
1539 {
fee933f1 1540 enum class bs_class = no_effect;
cabd4da6
JK
1541 if (bs->breakpoint_at == NULL)
1542 /* I suspect this can happen if it was a momentary breakpoint
1543 which has since been deleted. */
1544 continue;
1545 switch (bs->breakpoint_at->type)
1546 {
1547 case bp_breakpoint:
11054881 1548 case bp_hardware_breakpoint:
cabd4da6
JK
1549 case bp_until:
1550 case bp_finish:
1551 if (bs->stop)
1552 {
1553 if (bs->print)
1554 bs_class = bp_noisy;
1555 else
1556 bs_class = bp_silent;
1557 }
1558 else
1559 bs_class = bp_nostop;
1560 break;
1561 case bp_watchpoint:
999dd04b 1562 case bp_hardware_watchpoint:
11054881
KH
1563 case bp_read_watchpoint:
1564 case bp_access_watchpoint:
cabd4da6
JK
1565 if (bs->stop)
1566 {
1567 if (bs->print)
1568 bs_class = wp_noisy;
1569 else
1570 bs_class = wp_silent;
1571 }
1572 else
fe675038
JK
1573 /* There was a watchpoint, but we're not stopping. This requires
1574 no further action. */
1575 bs_class = no_effect;
cabd4da6
JK
1576 break;
1577 case bp_longjmp:
1578 bs_class = long_jump;
1579 break;
1580 case bp_longjmp_resume:
1581 bs_class = long_resume;
1582 break;
fe675038 1583 case bp_step_resume:
fe675038
JK
1584 if (bs->stop)
1585 {
d7e7e851 1586 bs_class = step_resume;
fe675038
JK
1587 }
1588 else
1589 /* It is for the wrong frame. */
1590 bs_class = bp_nostop;
bcc37718
JK
1591 break;
1592 case bp_through_sigtramp:
1593 bs_class = through_sig;
fe675038 1594 break;
999dd04b
JL
1595 case bp_watchpoint_scope:
1596 bs_class = bp_nostop;
1597 break;
1598
84d59861
JK
1599 case bp_call_dummy:
1600 /* Make sure the action is stop (silent or noisy), so infrun.c
1601 pops the dummy frame. */
1602 bs_class = bp_silent;
1603 retval.call_dummy = 1;
bb7b3800 1604 break;
cabd4da6
JK
1605 }
1606 current_action = table[(int)bs_class][(int)current_action];
1607 }
84d59861
JK
1608 retval.main_action = current_action;
1609 return retval;
cabd4da6 1610}
bd5635a1 1611
30875e1c
SG
1612/* Nonzero if we should step constantly (e.g. watchpoints on machines
1613 without hardware support). This isn't related to a specific bpstat,
1614 just to things like whether watchpoints are set. */
1615
bd5635a1
RP
1616int
1617bpstat_should_step ()
1618{
1619 struct breakpoint *b;
1620 ALL_BREAKPOINTS (b)
30875e1c 1621 if (b->enable == enabled && b->type == bp_watchpoint)
bd5635a1
RP
1622 return 1;
1623 return 0;
1624}
1625\f
1626/* Print information on breakpoint number BNUM, or -1 if all.
1627 If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1628 is nonzero, process only watchpoints. */
1629
1630static void
c8950965 1631breakpoint_1 (bnum, allflag)
bd5635a1 1632 int bnum;
80ba48f5 1633 int allflag;
bd5635a1
RP
1634{
1635 register struct breakpoint *b;
1636 register struct command_line *l;
1637 register struct symbol *sym;
1638 CORE_ADDR last_addr = (CORE_ADDR)-1;
30875e1c 1639 int found_a_breakpoint = 0;
11054881
KH
1640 static char *bptypes[] = {"breakpoint", "hw breakpoint",
1641 "until", "finish", "watchpoint",
1642 "hw watchpoint", "read watchpoint",
1643 "acc watchpoint", "longjmp",
999dd04b
JL
1644 "longjmp resume", "step resume",
1645 "watchpoint scope", "call dummy" };
80ba48f5 1646 static char *bpdisps[] = {"del", "dis", "keep"};
30875e1c 1647 static char bpenables[] = "ny";
0a62ff36 1648 char wrap_indent[80];
30875e1c 1649
bd5635a1 1650 ALL_BREAKPOINTS (b)
30875e1c
SG
1651 if (bnum == -1
1652 || bnum == b->number)
bd5635a1 1653 {
80ba48f5
SG
1654/* We only print out user settable breakpoints unless the allflag is set. */
1655 if (!allflag
1656 && b->type != bp_breakpoint
11054881 1657 && b->type != bp_hardware_breakpoint
999dd04b 1658 && b->type != bp_watchpoint
11054881
KH
1659 && b->type != bp_read_watchpoint
1660 && b->type != bp_access_watchpoint
999dd04b 1661 && b->type != bp_hardware_watchpoint)
80ba48f5
SG
1662 continue;
1663
30875e1c 1664 if (!found_a_breakpoint++)
47ebe8fd 1665 {
f2d9c058
KH
1666 annotate_breakpoints_headers ();
1667
1668 annotate_field (0);
1669 printf_filtered ("Num ");
1670 annotate_field (1);
1671 printf_filtered ("Type ");
1672 annotate_field (2);
1673 printf_filtered ("Disp ");
1674 annotate_field (3);
1675 printf_filtered ("Enb ");
1676 if (addressprint)
1677 {
1678 annotate_field (4);
1679 printf_filtered ("Address ");
1680 }
1681 annotate_field (5);
1682 printf_filtered ("What\n");
1683
1684 annotate_breakpoints_table ();
1685 }
1686
1687 annotate_record ();
1688 annotate_field (0);
1689 printf_filtered ("%-3d ", b->number);
1690 annotate_field (1);
1691 printf_filtered ("%-14s ", bptypes[(int)b->type]);
1692 annotate_field (2);
1693 printf_filtered ("%-4s ", bpdisps[(int)b->disposition]);
1694 annotate_field (3);
47ebe8fd
JK
1695 printf_filtered ("%-3c ", bpenables[(int)b->enable]);
1696
0a62ff36
JK
1697 strcpy (wrap_indent, " ");
1698 if (addressprint)
1699 strcat (wrap_indent, " ");
30875e1c 1700 switch (b->type)
bd5635a1 1701 {
30875e1c 1702 case bp_watchpoint:
999dd04b 1703 case bp_hardware_watchpoint:
11054881
KH
1704 case bp_read_watchpoint:
1705 case bp_access_watchpoint:
47ebe8fd
JK
1706 /* Field 4, the address, is omitted (which makes the columns
1707 not line up too nicely with the headers, but the effect
1708 is relatively readable). */
9f577285 1709 annotate_field (5);
199b2450 1710 print_expression (b->exp, gdb_stdout);
30875e1c 1711 break;
84d59861 1712
30875e1c 1713 case bp_breakpoint:
11054881 1714 case bp_hardware_breakpoint:
80ba48f5
SG
1715 case bp_until:
1716 case bp_finish:
1717 case bp_longjmp:
1718 case bp_longjmp_resume:
84d59861 1719 case bp_step_resume:
bcc37718 1720 case bp_through_sigtramp:
999dd04b 1721 case bp_watchpoint_scope:
bb7b3800 1722 case bp_call_dummy:
bd5635a1 1723 if (addressprint)
47ebe8fd 1724 {
f2d9c058 1725 annotate_field (4);
47ebe8fd
JK
1726 /* FIXME-32x64: need a print_address_numeric with
1727 field width */
1728 printf_filtered
1729 ("%s ",
1730 local_hex_string_custom
1731 ((unsigned long) b->address, "08l"));
1732 }
1733
f2d9c058 1734 annotate_field (5);
bd5635a1
RP
1735
1736 last_addr = b->address;
d889f6b7 1737 if (b->source_file)
bd5635a1
RP
1738 {
1739 sym = find_pc_function (b->address);
1740 if (sym)
1741 {
199b2450
TL
1742 fputs_filtered ("in ", gdb_stdout);
1743 fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
0a62ff36 1744 wrap_here (wrap_indent);
199b2450 1745 fputs_filtered (" at ", gdb_stdout);
bd5635a1 1746 }
199b2450 1747 fputs_filtered (b->source_file, gdb_stdout);
bd5635a1
RP
1748 printf_filtered (":%d", b->line_number);
1749 }
1750 else
199b2450 1751 print_address_symbolic (b->address, gdb_stdout, demangle, " ");
fee933f1 1752 break;
bd5635a1
RP
1753 }
1754
1755 printf_filtered ("\n");
1756
1757 if (b->frame)
833e0d94 1758 {
f2d9c058 1759 annotate_field (6);
47ebe8fd 1760
833e0d94 1761 printf_filtered ("\tstop only in stack frame at ");
d24c0599 1762 print_address_numeric (b->frame, 1, gdb_stdout);
833e0d94 1763 printf_filtered ("\n");
bcc37718 1764 }
47ebe8fd 1765
bd5635a1
RP
1766 if (b->cond)
1767 {
f2d9c058 1768 annotate_field (7);
47ebe8fd 1769
bd5635a1 1770 printf_filtered ("\tstop only if ");
199b2450 1771 print_expression (b->cond, gdb_stdout);
bd5635a1
RP
1772 printf_filtered ("\n");
1773 }
47ebe8fd 1774
9f577285
SS
1775 if (show_breakpoint_hit_counts && b->hit_count)
1776 {
1777 /* FIXME should make an annotation for this */
1778
16726dd1
JK
1779 printf_filtered ("\tbreakpoint already hit %d time%s\n",
1780 b->hit_count, (b->hit_count == 1 ? "" : "s"));
9f577285
SS
1781 }
1782
bd5635a1 1783 if (b->ignore_count)
47ebe8fd 1784 {
f2d9c058 1785 annotate_field (8);
47ebe8fd
JK
1786
1787 printf_filtered ("\tignore next %d hits\n", b->ignore_count);
1788 }
1789
bd5635a1 1790 if ((l = b->commands))
47ebe8fd 1791 {
f2d9c058 1792 annotate_field (9);
47ebe8fd
JK
1793
1794 while (l)
1795 {
1796 fputs_filtered ("\t", gdb_stdout);
1797 fputs_filtered (l->line, gdb_stdout);
1798 fputs_filtered ("\n", gdb_stdout);
1799 l = l->next;
1800 }
1801 }
bd5635a1
RP
1802 }
1803
fee933f1
RP
1804 if (!found_a_breakpoint)
1805 {
1806 if (bnum == -1)
1807 printf_filtered ("No breakpoints or watchpoints.\n");
1808 else
1809 printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
1810 }
30875e1c
SG
1811 else
1812 /* Compare against (CORE_ADDR)-1 in case some compiler decides
1813 that a comparison of an unsigned with -1 is always false. */
1814 if (last_addr != (CORE_ADDR)-1)
1815 set_next_address (last_addr);
47ebe8fd 1816
f2d9c058 1817 annotate_breakpoints_table_end ();
bd5635a1
RP
1818}
1819
bdbd5f50 1820/* ARGSUSED */
bd5635a1
RP
1821static void
1822breakpoints_info (bnum_exp, from_tty)
1823 char *bnum_exp;
1824 int from_tty;
1825{
1826 int bnum = -1;
1827
1828 if (bnum_exp)
1829 bnum = parse_and_eval_address (bnum_exp);
1830
c8950965 1831 breakpoint_1 (bnum, 0);
80ba48f5
SG
1832}
1833
9b280a7f
JG
1834#if MAINTENANCE_CMDS
1835
80ba48f5
SG
1836/* ARGSUSED */
1837static void
9b280a7f 1838maintenance_info_breakpoints (bnum_exp, from_tty)
80ba48f5
SG
1839 char *bnum_exp;
1840 int from_tty;
1841{
1842 int bnum = -1;
1843
1844 if (bnum_exp)
1845 bnum = parse_and_eval_address (bnum_exp);
1846
c8950965 1847 breakpoint_1 (bnum, 1);
bd5635a1
RP
1848}
1849
9b280a7f
JG
1850#endif
1851
bd5635a1
RP
1852/* Print a message describing any breakpoints set at PC. */
1853
1854static void
1855describe_other_breakpoints (pc)
1856 register CORE_ADDR pc;
1857{
1858 register int others = 0;
1859 register struct breakpoint *b;
1860
1861 ALL_BREAKPOINTS (b)
1862 if (b->address == pc)
1863 others++;
1864 if (others > 0)
1865 {
833e0d94 1866 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
bd5635a1
RP
1867 ALL_BREAKPOINTS (b)
1868 if (b->address == pc)
1869 {
1870 others--;
833e0d94
JK
1871 printf_filtered
1872 ("%d%s%s ",
1873 b->number,
1874 (b->enable == disabled) ? " (disabled)" : "",
1875 (others > 1) ? "," : ((others == 1) ? " and" : ""));
bd5635a1 1876 }
833e0d94 1877 printf_filtered ("also set at pc ");
d24c0599 1878 print_address_numeric (pc, 1, gdb_stdout);
833e0d94 1879 printf_filtered (".\n");
bd5635a1
RP
1880 }
1881}
1882\f
1883/* Set the default place to put a breakpoint
1884 for the `break' command with no arguments. */
1885
1886void
1887set_default_breakpoint (valid, addr, symtab, line)
1888 int valid;
1889 CORE_ADDR addr;
1890 struct symtab *symtab;
1891 int line;
1892{
1893 default_breakpoint_valid = valid;
1894 default_breakpoint_address = addr;
1895 default_breakpoint_symtab = symtab;
1896 default_breakpoint_line = line;
1897}
1898
1899/* Rescan breakpoints at address ADDRESS,
1900 marking the first one as "first" and any others as "duplicates".
1901 This is so that the bpt instruction is only inserted once. */
1902
1903static void
1904check_duplicates (address)
1905 CORE_ADDR address;
1906{
1907 register struct breakpoint *b;
1908 register int count = 0;
1909
30875e1c 1910 if (address == 0) /* Watchpoints are uninteresting */
f266e564
JK
1911 return;
1912
bd5635a1
RP
1913 ALL_BREAKPOINTS (b)
1914 if (b->enable != disabled && b->address == address)
1915 {
1916 count++;
1917 b->duplicate = count > 1;
1918 }
1919}
1920
1921/* Low level routine to set a breakpoint.
1922 Takes as args the three things that every breakpoint must have.
1923 Returns the breakpoint object so caller can set other things.
1924 Does not set the breakpoint number!
f266e564
JK
1925 Does not print anything.
1926
1927 ==> This routine should not be called if there is a chance of later
1928 error(); otherwise it leaves a bogus breakpoint on the chain. Validate
1929 your arguments BEFORE calling this routine! */
bd5635a1
RP
1930
1931static struct breakpoint *
1932set_raw_breakpoint (sal)
1933 struct symtab_and_line sal;
1934{
1935 register struct breakpoint *b, *b1;
1936
1937 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
4ed3a9ea 1938 memset (b, 0, sizeof (*b));
bd5635a1 1939 b->address = sal.pc;
d889f6b7
JK
1940 if (sal.symtab == NULL)
1941 b->source_file = NULL;
1942 else
1943 b->source_file = savestring (sal.symtab->filename,
1944 strlen (sal.symtab->filename));
706dc3ce
JL
1945 b->language = current_language->la_language;
1946 b->input_radix = input_radix;
199b2450 1947 b->thread = -1;
bd5635a1
RP
1948 b->line_number = sal.line;
1949 b->enable = enabled;
1950 b->next = 0;
1951 b->silent = 0;
1952 b->ignore_count = 0;
1953 b->commands = NULL;
30875e1c 1954 b->frame = 0;
bd5635a1
RP
1955
1956 /* Add this breakpoint to the end of the chain
1957 so that a list of breakpoints will come out in order
1958 of increasing numbers. */
1959
1960 b1 = breakpoint_chain;
1961 if (b1 == 0)
1962 breakpoint_chain = b;
1963 else
1964 {
1965 while (b1->next)
1966 b1 = b1->next;
1967 b1->next = b;
1968 }
1969
1970 check_duplicates (sal.pc);
6c803036 1971 breakpoints_changed ();
bd5635a1
RP
1972
1973 return b;
1974}
1975
30875e1c 1976static void
80ba48f5 1977create_longjmp_breakpoint(func_name)
30875e1c 1978 char *func_name;
30875e1c 1979{
30875e1c
SG
1980 struct symtab_and_line sal;
1981 struct breakpoint *b;
80ba48f5 1982 static int internal_breakpoint_number = -1;
30875e1c 1983
30875e1c
SG
1984 if (func_name != NULL)
1985 {
1986 struct minimal_symbol *m;
1987
1988 m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
1989 if (m)
2d313932 1990 sal.pc = SYMBOL_VALUE_ADDRESS (m);
30875e1c
SG
1991 else
1992 return;
1993 }
1994 else
1995 sal.pc = 0;
1996
1997 sal.symtab = NULL;
1998 sal.line = 0;
30875e1c 1999
80ba48f5 2000 b = set_raw_breakpoint(sal);
30875e1c
SG
2001 if (!b) return;
2002
80ba48f5 2003 b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
30875e1c
SG
2004 b->disposition = donttouch;
2005 b->enable = disabled;
2006 b->silent = 1;
80ba48f5
SG
2007 if (func_name)
2008 b->addr_string = strsave(func_name);
2009 b->number = internal_breakpoint_number--;
30875e1c 2010}
30875e1c
SG
2011
2012/* Call this routine when stepping and nexting to enable a breakpoint if we do
2013 a longjmp(). When we hit that breakpoint, call
2014 set_longjmp_resume_breakpoint() to figure out where we are going. */
2015
2016void
2017enable_longjmp_breakpoint()
2018{
80ba48f5
SG
2019 register struct breakpoint *b;
2020
2021 ALL_BREAKPOINTS (b)
2022 if (b->type == bp_longjmp)
9b280a7f
JG
2023 {
2024 b->enable = enabled;
2025 check_duplicates (b->address);
2026 }
30875e1c
SG
2027}
2028
2029void
2030disable_longjmp_breakpoint()
2031{
80ba48f5
SG
2032 register struct breakpoint *b;
2033
2034 ALL_BREAKPOINTS (b)
9b280a7f 2035 if ( b->type == bp_longjmp
80ba48f5 2036 || b->type == bp_longjmp_resume)
9b280a7f
JG
2037 {
2038 b->enable = disabled;
2039 check_duplicates (b->address);
2040 }
30875e1c
SG
2041}
2042
11054881
KH
2043int
2044hw_breakpoint_used_count()
2045{
2046 register struct breakpoint *b;
2047 int i = 0;
2048
2049 ALL_BREAKPOINTS (b)
2050 {
2051 if (b->type == bp_hardware_breakpoint && b->enable == enabled)
2052 i++;
2053 }
2054
2055 return i;
2056}
2057
2058int
2059hw_watchpoint_used_count(type, other_type_used)
2060 enum bptype type;
2061 int *other_type_used;
2062{
2063 register struct breakpoint *b;
2064 int i = 0;
2065
2066 *other_type_used = 0;
2067 ALL_BREAKPOINTS (b)
2068 {
2069 if (b->enable == enabled)
2070 {
2071 if (b->type == type) i++;
2072 else if ((b->type == bp_hardware_watchpoint ||
2073 b->type == bp_read_watchpoint ||
2074 b->type == bp_access_watchpoint)
2075 && b->enable == enabled)
2076 *other_type_used = 1;
2077 }
2078 }
2079 return i;
2080}
2081
30875e1c
SG
2082/* Call this after hitting the longjmp() breakpoint. Use this to set a new
2083 breakpoint at the target of the jmp_buf.
80ba48f5
SG
2084
2085 FIXME - This ought to be done by setting a temporary breakpoint that gets
2086 deleted automatically...
30875e1c
SG
2087*/
2088
2089void
2090set_longjmp_resume_breakpoint(pc, frame)
2091 CORE_ADDR pc;
706dc3ce 2092 struct frame_info *frame;
30875e1c 2093{
80ba48f5
SG
2094 register struct breakpoint *b;
2095
2096 ALL_BREAKPOINTS (b)
2097 if (b->type == bp_longjmp_resume)
2098 {
2099 b->address = pc;
2100 b->enable = enabled;
2101 if (frame != NULL)
706dc3ce 2102 b->frame = frame->frame;
80ba48f5
SG
2103 else
2104 b->frame = 0;
9b280a7f 2105 check_duplicates (b->address);
80ba48f5
SG
2106 return;
2107 }
30875e1c
SG
2108}
2109
bd5635a1
RP
2110/* Set a breakpoint that will evaporate an end of command
2111 at address specified by SAL.
2112 Restrict it to frame FRAME if FRAME is nonzero. */
2113
30875e1c
SG
2114struct breakpoint *
2115set_momentary_breakpoint (sal, frame, type)
bd5635a1 2116 struct symtab_and_line sal;
706dc3ce 2117 struct frame_info *frame;
30875e1c 2118 enum bptype type;
bd5635a1
RP
2119{
2120 register struct breakpoint *b;
2121 b = set_raw_breakpoint (sal);
30875e1c
SG
2122 b->type = type;
2123 b->enable = enabled;
2124 b->disposition = donttouch;
706dc3ce 2125 b->frame = (frame ? frame->frame : 0);
30875e1c 2126 return b;
bd5635a1
RP
2127}
2128
30875e1c 2129#if 0
bd5635a1
RP
2130void
2131clear_momentary_breakpoints ()
2132{
2133 register struct breakpoint *b;
2134 ALL_BREAKPOINTS (b)
30875e1c 2135 if (b->disposition == delete)
bd5635a1
RP
2136 {
2137 delete_breakpoint (b);
2138 break;
2139 }
2140}
30875e1c 2141#endif
bd5635a1
RP
2142\f
2143/* Tell the user we have just set a breakpoint B. */
9f577285 2144
bd5635a1
RP
2145static void
2146mention (b)
2147 struct breakpoint *b;
2148{
9f577285
SS
2149 int say_where = 0;
2150
d2a85f11
JMD
2151 /* FIXME: This is misplaced; mention() is called by things (like hitting a
2152 watchpoint) other than breakpoint creation. It should be possible to
2153 clean this up and at the same time replace the random calls to
2154 breakpoint_changed with this hook, as has already been done for
2155 delete_breakpoint_hook and so on. */
754e5da2
SG
2156 if (create_breakpoint_hook)
2157 create_breakpoint_hook (b);
2158
30875e1c 2159 switch (b->type)
bd5635a1 2160 {
30875e1c 2161 case bp_watchpoint:
bd5635a1 2162 printf_filtered ("Watchpoint %d: ", b->number);
199b2450 2163 print_expression (b->exp, gdb_stdout);
30875e1c 2164 break;
999dd04b
JL
2165 case bp_hardware_watchpoint:
2166 printf_filtered ("Hardware watchpoint %d: ", b->number);
2167 print_expression (b->exp, gdb_stdout);
2168 break;
11054881
KH
2169 case bp_read_watchpoint:
2170 printf_filtered ("Hardware read watchpoint %d: ", b->number);
2171 print_expression (b->exp, gdb_stdout);
2172 break;
2173 case bp_access_watchpoint:
2174 printf_filtered ("Hardware access(read/write) watchpoint %d: ",b->number);
2175 print_expression (b->exp, gdb_stdout);
2176 break;
30875e1c 2177 case bp_breakpoint:
9f577285
SS
2178 printf_filtered ("Breakpoint %d", b->number);
2179 say_where = 1;
51b57ded 2180 break;
11054881 2181 case bp_hardware_breakpoint:
9f577285
SS
2182 printf_filtered ("Hardware assisted breakpoint %d", b->number);
2183 say_where = 1;
11054881 2184 break;
51b57ded
FF
2185 case bp_until:
2186 case bp_finish:
2187 case bp_longjmp:
2188 case bp_longjmp_resume:
fee933f1 2189 case bp_step_resume:
bcc37718 2190 case bp_through_sigtramp:
199b2450 2191 case bp_call_dummy:
999dd04b 2192 case bp_watchpoint_scope:
51b57ded 2193 break;
bd5635a1 2194 }
9f577285
SS
2195 if (say_where)
2196 {
2197 if (addressprint || b->source_file == NULL)
2198 {
2199 printf_filtered (" at ");
2200 print_address_numeric (b->address, 1, gdb_stdout);
2201 }
2202 if (b->source_file)
2203 printf_filtered (": file %s, line %d.",
2204 b->source_file, b->line_number);
2205 }
bd5635a1
RP
2206 printf_filtered ("\n");
2207}
2208
2209#if 0
2210/* Nobody calls this currently. */
2211/* Set a breakpoint from a symtab and line.
2212 If TEMPFLAG is nonzero, it is a temporary breakpoint.
2213 ADDR_STRING is a malloc'd string holding the name of where we are
2214 setting the breakpoint. This is used later to re-set it after the
2215 program is relinked and symbols are reloaded.
2216 Print the same confirmation messages that the breakpoint command prints. */
2217
2218void
2219set_breakpoint (s, line, tempflag, addr_string)
2220 struct symtab *s;
2221 int line;
2222 int tempflag;
2223 char *addr_string;
2224{
2225 register struct breakpoint *b;
2226 struct symtab_and_line sal;
2227
2228 sal.symtab = s;
2229 sal.line = line;
30875e1c
SG
2230 sal.pc = 0;
2231 resolve_sal_pc (&sal); /* Might error out */
2232 describe_other_breakpoints (sal.pc);
bd5635a1 2233
30875e1c
SG
2234 b = set_raw_breakpoint (sal);
2235 set_breakpoint_count (breakpoint_count + 1);
2236 b->number = breakpoint_count;
2237 b->type = bp_breakpoint;
2238 b->cond = 0;
2239 b->addr_string = addr_string;
2240 b->enable = enabled;
2241 b->disposition = tempflag ? delete : donttouch;
bd5635a1 2242
30875e1c 2243 mention (b);
bd5635a1 2244}
30875e1c 2245#endif /* 0 */
bd5635a1
RP
2246\f
2247/* Set a breakpoint according to ARG (function, linenum or *address)
11054881
KH
2248 flag: first bit : 0 non-temporary, 1 temporary.
2249 second bit : 0 normal breakpoint, 1 hardware breakpoint. */
bd5635a1
RP
2250
2251static void
11054881 2252break_command_1 (arg, flag, from_tty)
bd5635a1 2253 char *arg;
11054881 2254 int flag, from_tty;
bd5635a1 2255{
11054881 2256 int tempflag, hardwareflag;
bd5635a1
RP
2257 struct symtabs_and_lines sals;
2258 struct symtab_and_line sal;
2259 register struct expression *cond = 0;
2260 register struct breakpoint *b;
2261
2262 /* Pointers in arg to the start, and one past the end, of the condition. */
2263 char *cond_start = NULL;
fee933f1 2264 char *cond_end = NULL;
bd5635a1
RP
2265 /* Pointers in arg to the start, and one past the end,
2266 of the address part. */
2267 char *addr_start = NULL;
fee933f1 2268 char *addr_end = NULL;
d889f6b7 2269 struct cleanup *old_chain;
fee933f1 2270 struct cleanup *canonical_strings_chain = NULL;
d889f6b7 2271 char **canonical = (char **)NULL;
bd5635a1 2272 int i;
199b2450 2273 int thread;
bd5635a1 2274
11054881
KH
2275 hardwareflag = flag & 2;
2276 tempflag = flag & 1;
2277
bd5635a1
RP
2278 sals.sals = NULL;
2279 sals.nelts = 0;
2280
2281 sal.line = sal.pc = sal.end = 0;
2282 sal.symtab = 0;
2283
2284 /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
2285
2286 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
2287 && (arg[2] == ' ' || arg[2] == '\t')))
2288 {
2289 if (default_breakpoint_valid)
2290 {
2291 sals.sals = (struct symtab_and_line *)
2292 xmalloc (sizeof (struct symtab_and_line));
2293 sal.pc = default_breakpoint_address;
2294 sal.line = default_breakpoint_line;
2295 sal.symtab = default_breakpoint_symtab;
2296 sals.sals[0] = sal;
2297 sals.nelts = 1;
2298 }
2299 else
2300 error ("No default breakpoint address now.");
2301 }
2302 else
2303 {
2304 addr_start = arg;
2305
2306 /* Force almost all breakpoints to be in terms of the
2307 current_source_symtab (which is decode_line_1's default). This
2308 should produce the results we want almost all of the time while
2309 leaving default_breakpoint_* alone. */
2310 if (default_breakpoint_valid
2311 && (!current_source_symtab
2312 || (arg && (*arg == '+' || *arg == '-'))))
2313 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
d889f6b7 2314 default_breakpoint_line, &canonical);
bd5635a1 2315 else
d889f6b7 2316 sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, &canonical);
bd5635a1
RP
2317
2318 addr_end = arg;
2319 }
2320
2321 if (! sals.nelts)
2322 return;
2323
d889f6b7
JK
2324 /* Make sure that all storage allocated in decode_line_1 gets freed in case
2325 the following `for' loop errors out. */
2326 old_chain = make_cleanup (free, sals.sals);
2327 if (canonical != (char **)NULL)
2328 {
2329 make_cleanup (free, canonical);
2330 canonical_strings_chain = make_cleanup (null_cleanup, 0);
2331 for (i = 0; i < sals.nelts; i++)
2332 {
2333 if (canonical[i] != NULL)
2334 make_cleanup (free, canonical[i]);
2335 }
2336 }
2337
199b2450
TL
2338 thread = -1; /* No specific thread yet */
2339
30875e1c
SG
2340 /* Resolve all line numbers to PC's, and verify that conditions
2341 can be parsed, before setting any breakpoints. */
bd5635a1
RP
2342 for (i = 0; i < sals.nelts; i++)
2343 {
199b2450
TL
2344 char *tok, *end_tok;
2345 int toklen;
2346
30875e1c 2347 resolve_sal_pc (&sals.sals[i]);
bd5635a1 2348
199b2450
TL
2349 tok = arg;
2350
2351 while (tok && *tok)
bd5635a1 2352 {
199b2450
TL
2353 while (*tok == ' ' || *tok == '\t')
2354 tok++;
2355
2356 end_tok = tok;
2357
2358 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
2359 end_tok++;
2360
2361 toklen = end_tok - tok;
2362
2363 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
2364 {
2365 tok = cond_start = end_tok + 1;
2366 cond = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
2367 cond_end = tok;
2368 }
2369 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
bd5635a1 2370 {
199b2450
TL
2371 char *tmptok;
2372
2373 tok = end_tok + 1;
2374 tmptok = tok;
2375 thread = strtol (tok, &tok, 0);
2376 if (tok == tmptok)
2377 error ("Junk after thread keyword.");
2378 if (!valid_thread_id (thread))
2379 error ("Unknown thread %d\n", thread);
bd5635a1
RP
2380 }
2381 else
2382 error ("Junk at end of arguments.");
2383 }
bd5635a1 2384 }
11054881
KH
2385 if (hardwareflag)
2386 {
557f3a0e
SS
2387 int i, target_resources_ok;
2388
2389 i = hw_breakpoint_used_count ();
2390 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
2391 bp_hardware_breakpoint, i + sals.nelts, 0);
11054881
KH
2392 if (target_resources_ok == 0)
2393 error ("No hardware breakpoint support in the target.");
2394 else if (target_resources_ok < 0)
2395 error ("Hardware breakpoints used exceeds limit.");
2396 }
bd5635a1 2397
d889f6b7
JK
2398 /* Remove the canonical strings from the cleanup, they are needed below. */
2399 if (canonical != (char **)NULL)
2400 discard_cleanups (canonical_strings_chain);
2401
30875e1c 2402 /* Now set all the breakpoints. */
bd5635a1
RP
2403 for (i = 0; i < sals.nelts; i++)
2404 {
2405 sal = sals.sals[i];
2406
2407 if (from_tty)
2408 describe_other_breakpoints (sal.pc);
2409
2410 b = set_raw_breakpoint (sal);
2411 set_breakpoint_count (breakpoint_count + 1);
2412 b->number = breakpoint_count;
11054881 2413 b->type = hardwareflag ? bp_hardware_breakpoint : bp_breakpoint;
bd5635a1 2414 b->cond = cond;
199b2450 2415 b->thread = thread;
0a97f6c4 2416
d889f6b7
JK
2417 /* If a canonical line spec is needed use that instead of the
2418 command string. */
2419 if (canonical != (char **)NULL && canonical[i] != NULL)
2420 b->addr_string = canonical[i];
2421 else if (addr_start)
bd5635a1
RP
2422 b->addr_string = savestring (addr_start, addr_end - addr_start);
2423 if (cond_start)
2424 b->cond_string = savestring (cond_start, cond_end - cond_start);
2425
30875e1c
SG
2426 b->enable = enabled;
2427 b->disposition = tempflag ? delete : donttouch;
bd5635a1
RP
2428
2429 mention (b);
2430 }
2431
2432 if (sals.nelts > 1)
2433 {
833e0d94
JK
2434 printf_filtered ("Multiple breakpoints were set.\n");
2435 printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
bd5635a1 2436 }
d889f6b7 2437 do_cleanups (old_chain);
bd5635a1
RP
2438}
2439
30875e1c
SG
2440/* Helper function for break_command_1 and disassemble_command. */
2441
2442void
2443resolve_sal_pc (sal)
2444 struct symtab_and_line *sal;
2445{
2446 CORE_ADDR pc;
2447
2448 if (sal->pc == 0 && sal->symtab != 0)
2449 {
2450 pc = find_line_pc (sal->symtab, sal->line);
2451 if (pc == 0)
2452 error ("No line %d in file \"%s\".",
2453 sal->line, sal->symtab->filename);
2454 sal->pc = pc;
2455 }
2456}
2457
11054881
KH
2458#define BP_TEMPFLAG 1
2459#define BP_HARDWAREFLAG 2
bd5635a1
RP
2460void
2461break_command (arg, from_tty)
2462 char *arg;
2463 int from_tty;
2464{
2465 break_command_1 (arg, 0, from_tty);
2466}
2467
2468static void
2469tbreak_command (arg, from_tty)
2470 char *arg;
2471 int from_tty;
2472{
11054881
KH
2473 break_command_1 (arg, BP_TEMPFLAG, from_tty);
2474}
2475
2476static void
2477hbreak_command (arg, from_tty)
2478 char *arg;
2479 int from_tty;
2480{
2481 break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
2482}
2483
2484static void
2485thbreak_command (arg, from_tty)
2486 char *arg;
2487 int from_tty;
2488{
2489 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
bd5635a1
RP
2490}
2491
bdbd5f50 2492/* ARGSUSED */
11054881
KH
2493/* accessflag: 0: watch write, 1: watch read, 2: watch access(read or write)
2494*/
bd5635a1 2495static void
11054881 2496watch_command_1 (arg, accessflag, from_tty)
bd5635a1 2497 char *arg;
11054881 2498 int accessflag;
bd5635a1
RP
2499 int from_tty;
2500{
2501 struct breakpoint *b;
2502 struct symtab_and_line sal;
f266e564
JK
2503 struct expression *exp;
2504 struct block *exp_valid_block;
11054881 2505 struct value *val, *mark;
706dc3ce 2506 struct frame_info *frame, *prev_frame;
11054881
KH
2507 char *exp_start = NULL;
2508 char *exp_end = NULL;
2509 char *tok, *end_tok;
2510 int toklen;
2511 char *cond_start = NULL;
2512 char *cond_end = NULL;
2513 struct expression *cond = NULL;
2514 int i, other_type_used, target_resources_ok;
2515 enum bptype bp_type;
2516 int mem_cnt = 0;
bd5635a1 2517
30875e1c 2518 sal.pc = 0;
bd5635a1
RP
2519 sal.symtab = NULL;
2520 sal.line = 0;
2521
f266e564
JK
2522 /* Parse arguments. */
2523 innermost_block = NULL;
11054881
KH
2524 exp_start = arg;
2525 exp = parse_exp_1 (&arg, 0, 0);
2526 exp_end = arg;
f266e564 2527 exp_valid_block = innermost_block;
11054881 2528 mark = value_mark ();
f266e564
JK
2529 val = evaluate_expression (exp);
2530 release_value (val);
2d313932
JK
2531 if (VALUE_LAZY (val))
2532 value_fetch_lazy (val);
f266e564 2533
11054881
KH
2534 tok = arg;
2535 while (*tok == ' ' || *tok == '\t')
2536 tok++;
2537 end_tok = tok;
2538
2539 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
2540 end_tok++;
2541
2542 toklen = end_tok - tok;
2543 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
2544 {
2545 tok = cond_start = end_tok + 1;
2546 cond = parse_exp_1 (&tok, 0, 0);
2547 cond_end = tok;
2548 }
2549 if (*tok)
2550 error("Junk at end of command.");
2551
2552 if (accessflag == 1) bp_type = bp_read_watchpoint;
2553 else if (accessflag == 2) bp_type = bp_access_watchpoint;
2554 else bp_type = bp_hardware_watchpoint;
2555
2556 mem_cnt = can_use_hardware_watchpoint (val);
2557 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
2558 error ("Expression cannot be implemented with read/access watchpoint.");
2559 if (mem_cnt != 0) {
2560 i = hw_watchpoint_used_count (bp_type, &other_type_used);
2561 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
2562 bp_type, i + mem_cnt, other_type_used);
2563 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
2564 error ("Target does not have this type of hardware watchpoint support.");
2565 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
2566 error ("Target resources have been allocated for other types of watchpoints.");
2567 }
2568
f266e564 2569 /* Now set up the breakpoint. */
bd5635a1
RP
2570 b = set_raw_breakpoint (sal);
2571 set_breakpoint_count (breakpoint_count + 1);
2572 b->number = breakpoint_count;
30875e1c 2573 b->disposition = donttouch;
f266e564
JK
2574 b->exp = exp;
2575 b->exp_valid_block = exp_valid_block;
11054881 2576 b->exp_string = savestring (exp_start, exp_end - exp_start);
f266e564 2577 b->val = val;
11054881
KH
2578 b->cond = cond;
2579 if (cond_start)
2580 b->cond_string = savestring (cond_start, cond_end - cond_start);
2581 else
2582 b->cond_string = 0;
2583
999dd04b
JL
2584 frame = block_innermost_frame (exp_valid_block);
2585 if (frame)
2586 {
2587 prev_frame = get_prev_frame (frame);
706dc3ce 2588 b->watchpoint_frame = frame->frame;
999dd04b
JL
2589 }
2590 else
9e8db445 2591 b->watchpoint_frame = (CORE_ADDR)0;
999dd04b 2592
11054881
KH
2593 if (mem_cnt && target_resources_ok > 0)
2594 b->type = bp_type;
999dd04b
JL
2595 else
2596 b->type = bp_watchpoint;
2597
2598 /* If the expression is "local", then set up a "watchpoint scope"
2599 breakpoint at the point where we've left the scope of the watchpoint
2600 expression. */
2601 if (innermost_block)
2602 {
2603 struct breakpoint *scope_breakpoint;
2604 struct symtab_and_line scope_sal;
2605
2606 if (prev_frame)
2607 {
2608 scope_sal.pc = get_frame_pc (prev_frame);
2609 scope_sal.symtab = NULL;
2610 scope_sal.line = 0;
2611
2612 scope_breakpoint = set_raw_breakpoint (scope_sal);
2613 set_breakpoint_count (breakpoint_count + 1);
2614 scope_breakpoint->number = breakpoint_count;
2615
2616 scope_breakpoint->type = bp_watchpoint_scope;
2617 scope_breakpoint->enable = enabled;
2618
2619 /* Automatically delete the breakpoint when it hits. */
2620 scope_breakpoint->disposition = delete;
2621
2622 /* Only break in the proper frame (help with recursion). */
2623 scope_breakpoint->frame = prev_frame->frame;
2624
2625 /* Set the address at which we will stop. */
2626 scope_breakpoint->address = get_frame_pc (prev_frame);
2627
2628 /* The scope breakpoint is related to the watchpoint. We
2629 will need to act on them together. */
2630 b->related_breakpoint = scope_breakpoint;
2631 }
2632 }
11054881 2633 value_free_to_mark (mark);
bd5635a1
RP
2634 mention (b);
2635}
999dd04b 2636
11054881
KH
2637/* Return count of locations need to be watched and can be handled
2638 in hardware. If the watchpoint can not be handled
999dd04b
JL
2639 in hardware return zero. */
2640
2641static int
11054881
KH
2642can_use_hardware_watchpoint (v)
2643 struct value *v;
999dd04b 2644{
11054881 2645 int found_memory_cnt = 0;
999dd04b
JL
2646
2647 /* Make sure all the intermediate values are in memory. Also make sure
2648 we found at least one memory expression. Guards against watch 0x12345,
2649 which is meaningless, but could cause errors if one tries to insert a
2650 hardware watchpoint for the constant expression. */
11054881 2651 for ( ; v; v = v->next)
999dd04b 2652 {
11054881
KH
2653 if (v->lval == lval_memory)
2654 {
2655 if (TYPE_LENGTH (VALUE_TYPE (v)) <= REGISTER_SIZE)
2656 found_memory_cnt++;
2657 }
2658 else if (v->lval != not_lval && v->modifiable == 0)
999dd04b 2659 return 0;
999dd04b
JL
2660 }
2661
2662 /* The expression itself looks suitable for using a hardware
2663 watchpoint, but give the target machine a chance to reject it. */
11054881
KH
2664 return found_memory_cnt;
2665}
2666
2667static void watch_command (arg, from_tty)
2668 char *arg;
2669 int from_tty;
2670{
2671 watch_command_1 (arg, 0, from_tty);
2672}
2673
2674static void rwatch_command (arg, from_tty)
2675 char *arg;
2676 int from_tty;
2677{
2678 watch_command_1 (arg, 1, from_tty);
2679}
2680
2681static void awatch_command (arg, from_tty)
2682 char *arg;
2683 int from_tty;
2684{
2685 watch_command_1 (arg, 2, from_tty);
999dd04b
JL
2686}
2687
bd5635a1 2688\f
706dc3ce
JL
2689/* Helper routine for the until_command routine in infcmd.c. Here
2690 because it uses the mechanisms of breakpoints. */
2691
bdbd5f50 2692/* ARGSUSED */
bd5635a1
RP
2693void
2694until_break_command (arg, from_tty)
2695 char *arg;
2696 int from_tty;
2697{
2698 struct symtabs_and_lines sals;
2699 struct symtab_and_line sal;
706dc3ce 2700 struct frame_info *prev_frame = get_prev_frame (selected_frame);
30875e1c
SG
2701 struct breakpoint *breakpoint;
2702 struct cleanup *old_chain;
bd5635a1
RP
2703
2704 clear_proceed_status ();
2705
2706 /* Set a breakpoint where the user wants it and at return from
2707 this function */
2708
2709 if (default_breakpoint_valid)
2710 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
d889f6b7 2711 default_breakpoint_line, (char ***)NULL);
bd5635a1 2712 else
d889f6b7 2713 sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, (char ***)NULL);
bd5635a1
RP
2714
2715 if (sals.nelts != 1)
2716 error ("Couldn't get information on specified line.");
2717
2718 sal = sals.sals[0];
c8950965 2719 free ((PTR)sals.sals); /* malloc'd, so freed */
bd5635a1
RP
2720
2721 if (*arg)
2722 error ("Junk at end of arguments.");
2723
30875e1c 2724 resolve_sal_pc (&sal);
bd5635a1 2725
30875e1c 2726 breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
bd5635a1 2727
30875e1c
SG
2728 old_chain = make_cleanup(delete_breakpoint, breakpoint);
2729
bd5635a1
RP
2730 /* Keep within the current frame */
2731
2732 if (prev_frame)
2733 {
706dc3ce
JL
2734 sal = find_pc_line (prev_frame->pc, 0);
2735 sal.pc = prev_frame->pc;
30875e1c
SG
2736 breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
2737 make_cleanup(delete_breakpoint, breakpoint);
bd5635a1
RP
2738 }
2739
d7e7e851 2740 proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
30875e1c 2741 do_cleanups(old_chain);
bd5635a1
RP
2742}
2743\f
bdbd5f50
JG
2744#if 0
2745/* These aren't used; I don't konw what they were for. */
bd5635a1
RP
2746/* Set a breakpoint at the catch clause for NAME. */
2747static int
2748catch_breakpoint (name)
2749 char *name;
2750{
2751}
2752
2753static int
2754disable_catch_breakpoint ()
2755{
2756}
2757
2758static int
2759delete_catch_breakpoint ()
2760{
2761}
2762
2763static int
2764enable_catch_breakpoint ()
2765{
2766}
bdbd5f50 2767#endif /* 0 */
bd5635a1
RP
2768
2769struct sal_chain
2770{
2771 struct sal_chain *next;
2772 struct symtab_and_line sal;
2773};
2774
bdbd5f50
JG
2775#if 0
2776/* This isn't used; I don't know what it was for. */
bd5635a1
RP
2777/* For each catch clause identified in ARGS, run FUNCTION
2778 with that clause as an argument. */
2779static struct symtabs_and_lines
2780map_catch_names (args, function)
2781 char *args;
2782 int (*function)();
2783{
2784 register char *p = args;
2785 register char *p1;
2786 struct symtabs_and_lines sals;
bdbd5f50 2787#if 0
bd5635a1 2788 struct sal_chain *sal_chain = 0;
bdbd5f50 2789#endif
bd5635a1
RP
2790
2791 if (p == 0)
2792 error_no_arg ("one or more catch names");
2793
2794 sals.nelts = 0;
2795 sals.sals = NULL;
2796
2797 while (*p)
2798 {
2799 p1 = p;
2800 /* Don't swallow conditional part. */
2801 if (p1[0] == 'i' && p1[1] == 'f'
2802 && (p1[2] == ' ' || p1[2] == '\t'))
2803 break;
2804
2805 if (isalpha (*p1))
2806 {
2807 p1++;
2808 while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
2809 p1++;
2810 }
2811
2812 if (*p1 && *p1 != ' ' && *p1 != '\t')
2813 error ("Arguments must be catch names.");
2814
2815 *p1 = 0;
2816#if 0
2817 if (function (p))
2818 {
2819 struct sal_chain *next
2820 = (struct sal_chain *)alloca (sizeof (struct sal_chain));
2821 next->next = sal_chain;
2822 next->sal = get_catch_sal (p);
2823 sal_chain = next;
2824 goto win;
2825 }
2826#endif
199b2450 2827 printf_unfiltered ("No catch clause for exception %s.\n", p);
bdbd5f50 2828#if 0
bd5635a1 2829 win:
bdbd5f50 2830#endif
bd5635a1
RP
2831 p = p1;
2832 while (*p == ' ' || *p == '\t') p++;
2833 }
2834}
bdbd5f50 2835#endif /* 0 */
bd5635a1
RP
2836
2837/* This shares a lot of code with `print_frame_label_vars' from stack.c. */
2838
2839static struct symtabs_and_lines
2840get_catch_sals (this_level_only)
2841 int this_level_only;
2842{
bd5635a1 2843 register struct blockvector *bl;
777bef06 2844 register struct block *block;
bd5635a1 2845 int index, have_default = 0;
777bef06 2846 CORE_ADDR pc;
bd5635a1
RP
2847 struct symtabs_and_lines sals;
2848 struct sal_chain *sal_chain = 0;
2849 char *blocks_searched;
2850
777bef06
JK
2851 /* Not sure whether an error message is always the correct response,
2852 but it's better than a core dump. */
2853 if (selected_frame == NULL)
2854 error ("No selected frame.");
2855 block = get_frame_block (selected_frame);
706dc3ce 2856 pc = selected_frame->pc;
777bef06 2857
bd5635a1
RP
2858 sals.nelts = 0;
2859 sals.sals = NULL;
2860
2861 if (block == 0)
2862 error ("No symbol table info available.\n");
2863
2864 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
2865 blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
4ed3a9ea 2866 memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
bd5635a1
RP
2867
2868 while (block != 0)
2869 {
2870 CORE_ADDR end = BLOCK_END (block) - 4;
2871 int last_index;
2872
2873 if (bl != blockvector_for_pc (end, &index))
2874 error ("blockvector blotch");
2875 if (BLOCKVECTOR_BLOCK (bl, index) != block)
2876 error ("blockvector botch");
2877 last_index = BLOCKVECTOR_NBLOCKS (bl);
2878 index += 1;
2879
2880 /* Don't print out blocks that have gone by. */
2881 while (index < last_index
2882 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
2883 index++;
2884
2885 while (index < last_index
2886 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
2887 {
2888 if (blocks_searched[index] == 0)
2889 {
2890 struct block *b = BLOCKVECTOR_BLOCK (bl, index);
2891 int nsyms;
2892 register int i;
2893 register struct symbol *sym;
2894
2895 nsyms = BLOCK_NSYMS (b);
2896
2897 for (i = 0; i < nsyms; i++)
2898 {
2899 sym = BLOCK_SYM (b, i);
2d313932 2900 if (STREQ (SYMBOL_NAME (sym), "default"))
bd5635a1
RP
2901 {
2902 if (have_default)
2903 continue;
2904 have_default = 1;
2905 }
2906 if (SYMBOL_CLASS (sym) == LOC_LABEL)
2907 {
2908 struct sal_chain *next = (struct sal_chain *)
2909 alloca (sizeof (struct sal_chain));
2910 next->next = sal_chain;
2911 next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2912 sal_chain = next;
2913 }
2914 }
2915 blocks_searched[index] = 1;
2916 }
2917 index++;
2918 }
2919 if (have_default)
2920 break;
2921 if (sal_chain && this_level_only)
2922 break;
2923
2924 /* After handling the function's top-level block, stop.
2925 Don't continue to its superblock, the block of
2926 per-file symbols. */
2927 if (BLOCK_FUNCTION (block))
2928 break;
2929 block = BLOCK_SUPERBLOCK (block);
2930 }
2931
2932 if (sal_chain)
2933 {
2934 struct sal_chain *tmp_chain;
2935
2936 /* Count the number of entries. */
2937 for (index = 0, tmp_chain = sal_chain; tmp_chain;
2938 tmp_chain = tmp_chain->next)
2939 index++;
2940
2941 sals.nelts = index;
2942 sals.sals = (struct symtab_and_line *)
2943 xmalloc (index * sizeof (struct symtab_and_line));
2944 for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
2945 sals.sals[index] = sal_chain->sal;
2946 }
2947
2948 return sals;
2949}
2950
2951/* Commands to deal with catching exceptions. */
2952
30875e1c 2953static void
bd5635a1
RP
2954catch_command_1 (arg, tempflag, from_tty)
2955 char *arg;
2956 int tempflag;
2957 int from_tty;
2958{
2959 /* First, translate ARG into something we can deal with in terms
2960 of breakpoints. */
2961
2962 struct symtabs_and_lines sals;
2963 struct symtab_and_line sal;
2964 register struct expression *cond = 0;
2965 register struct breakpoint *b;
2966 char *save_arg;
2967 int i;
bd5635a1
RP
2968
2969 sal.line = sal.pc = sal.end = 0;
2970 sal.symtab = 0;
2971
2972 /* If no arg given, or if first arg is 'if ', all active catch clauses
2973 are breakpointed. */
2974
2975 if (!arg || (arg[0] == 'i' && arg[1] == 'f'
2976 && (arg[2] == ' ' || arg[2] == '\t')))
2977 {
2978 /* Grab all active catch clauses. */
2979 sals = get_catch_sals (0);
2980 }
2981 else
2982 {
2983 /* Grab selected catch clauses. */
fe675038 2984 error ("catch NAME not implemented");
bdbd5f50
JG
2985#if 0
2986 /* This isn't used; I don't know what it was for. */
bd5635a1 2987 sals = map_catch_names (arg, catch_breakpoint);
bdbd5f50 2988#endif
bd5635a1
RP
2989 }
2990
2991 if (! sals.nelts)
2992 return;
2993
2994 save_arg = arg;
2995 for (i = 0; i < sals.nelts; i++)
2996 {
30875e1c 2997 resolve_sal_pc (&sals.sals[i]);
bd5635a1
RP
2998
2999 while (arg && *arg)
3000 {
3001 if (arg[0] == 'i' && arg[1] == 'f'
3002 && (arg[2] == ' ' || arg[2] == '\t'))
30875e1c
SG
3003 cond = parse_exp_1 ((arg += 2, &arg),
3004 block_for_pc (sals.sals[i].pc), 0);
bd5635a1
RP
3005 else
3006 error ("Junk at end of arguments.");
3007 }
3008 arg = save_arg;
bd5635a1
RP
3009 }
3010
3011 for (i = 0; i < sals.nelts; i++)
3012 {
3013 sal = sals.sals[i];
3014
3015 if (from_tty)
3016 describe_other_breakpoints (sal.pc);
3017
3018 b = set_raw_breakpoint (sal);
30875e1c
SG
3019 set_breakpoint_count (breakpoint_count + 1);
3020 b->number = breakpoint_count;
3021 b->type = bp_breakpoint;
bd5635a1 3022 b->cond = cond;
30875e1c
SG
3023 b->enable = enabled;
3024 b->disposition = tempflag ? delete : donttouch;
bd5635a1 3025
d889f6b7 3026 mention (b);
bd5635a1
RP
3027 }
3028
3029 if (sals.nelts > 1)
3030 {
199b2450
TL
3031 printf_unfiltered ("Multiple breakpoints were set.\n");
3032 printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
bd5635a1 3033 }
c8950965 3034 free ((PTR)sals.sals);
bd5635a1
RP
3035}
3036
bdbd5f50
JG
3037#if 0
3038/* These aren't used; I don't know what they were for. */
bd5635a1
RP
3039/* Disable breakpoints on all catch clauses described in ARGS. */
3040static void
3041disable_catch (args)
3042 char *args;
3043{
3044 /* Map the disable command to catch clauses described in ARGS. */
3045}
3046
3047/* Enable breakpoints on all catch clauses described in ARGS. */
3048static void
3049enable_catch (args)
3050 char *args;
3051{
3052 /* Map the disable command to catch clauses described in ARGS. */
3053}
3054
3055/* Delete breakpoints on all catch clauses in the active scope. */
3056static void
3057delete_catch (args)
3058 char *args;
3059{
3060 /* Map the delete command to catch clauses described in ARGS. */
3061}
bdbd5f50 3062#endif /* 0 */
bd5635a1
RP
3063
3064static void
3065catch_command (arg, from_tty)
3066 char *arg;
3067 int from_tty;
3068{
3069 catch_command_1 (arg, 0, from_tty);
3070}
3071\f
3072static void
3073clear_command (arg, from_tty)
3074 char *arg;
3075 int from_tty;
3076{
3077 register struct breakpoint *b, *b1;
3078 struct symtabs_and_lines sals;
3079 struct symtab_and_line sal;
3080 register struct breakpoint *found;
3081 int i;
3082
3083 if (arg)
3084 {
3085 sals = decode_line_spec (arg, 1);
3086 }
3087 else
3088 {
3089 sals.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
3090 sal.line = default_breakpoint_line;
3091 sal.symtab = default_breakpoint_symtab;
3092 sal.pc = 0;
3093 if (sal.symtab == 0)
3094 error ("No source file specified.");
3095
3096 sals.sals[0] = sal;
3097 sals.nelts = 1;
3098 }
3099
3100 for (i = 0; i < sals.nelts; i++)
3101 {
3102 /* If exact pc given, clear bpts at that pc.
3103 But if sal.pc is zero, clear all bpts on specified line. */
3104 sal = sals.sals[i];
3105 found = (struct breakpoint *) 0;
3106 while (breakpoint_chain
d889f6b7
JK
3107 && (sal.pc
3108 ? breakpoint_chain->address == sal.pc
3109 : (breakpoint_chain->source_file != NULL
3110 && sal.symtab != NULL
3111 && STREQ (breakpoint_chain->source_file,
3112 sal.symtab->filename)
bd5635a1
RP
3113 && breakpoint_chain->line_number == sal.line)))
3114 {
3115 b1 = breakpoint_chain;
3116 breakpoint_chain = b1->next;
3117 b1->next = found;
3118 found = b1;
3119 }
3120
3121 ALL_BREAKPOINTS (b)
3122 while (b->next
30875e1c 3123 && b->next->type != bp_watchpoint
999dd04b 3124 && b->next->type != bp_hardware_watchpoint
11054881
KH
3125 && b->next->type != bp_read_watchpoint
3126 && b->next->type != bp_access_watchpoint
d889f6b7
JK
3127 && (sal.pc
3128 ? b->next->address == sal.pc
3129 : (b->next->source_file != NULL
3130 && sal.symtab != NULL
3131 && STREQ (b->next->source_file, sal.symtab->filename)
bd5635a1
RP
3132 && b->next->line_number == sal.line)))
3133 {
3134 b1 = b->next;
3135 b->next = b1->next;
3136 b1->next = found;
3137 found = b1;
3138 }
3139
3140 if (found == 0)
3141 {
3142 if (arg)
3143 error ("No breakpoint at %s.", arg);
3144 else
3145 error ("No breakpoint at this line.");
3146 }
3147
3148 if (found->next) from_tty = 1; /* Always report if deleted more than one */
199b2450 3149 if (from_tty) printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
6c803036 3150 breakpoints_changed ();
bd5635a1
RP
3151 while (found)
3152 {
199b2450 3153 if (from_tty) printf_unfiltered ("%d ", found->number);
bd5635a1
RP
3154 b1 = found->next;
3155 delete_breakpoint (found);
3156 found = b1;
3157 }
199b2450 3158 if (from_tty) putchar_unfiltered ('\n');
bd5635a1 3159 }
c8950965 3160 free ((PTR)sals.sals);
bd5635a1
RP
3161}
3162\f
3163/* Delete breakpoint in BS if they are `delete' breakpoints.
3164 This is called after any breakpoint is hit, or after errors. */
3165
3166void
3167breakpoint_auto_delete (bs)
3168 bpstat bs;
3169{
3170 for (; bs; bs = bs->next)
cef4c2e7
PS
3171 if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete
3172 && bs->stop)
bd5635a1
RP
3173 delete_breakpoint (bs->breakpoint_at);
3174}
3175
3176/* Delete a breakpoint and clean up all traces of it in the data structures. */
3177
30875e1c 3178void
bd5635a1
RP
3179delete_breakpoint (bpt)
3180 struct breakpoint *bpt;
3181{
3182 register struct breakpoint *b;
3183 register bpstat bs;
3184
754e5da2
SG
3185 if (delete_breakpoint_hook)
3186 delete_breakpoint_hook (bpt);
3187
bd5635a1 3188 if (bpt->inserted)
999dd04b
JL
3189 remove_breakpoint (bpt);
3190
bd5635a1
RP
3191 if (breakpoint_chain == bpt)
3192 breakpoint_chain = bpt->next;
3193
3194 ALL_BREAKPOINTS (b)
3195 if (b->next == bpt)
3196 {
3197 b->next = bpt->next;
3198 break;
3199 }
3200
3201 check_duplicates (bpt->address);
fe675038
JK
3202 /* If this breakpoint was inserted, and there is another breakpoint
3203 at the same address, we need to insert the other breakpoint. */
999dd04b 3204 if (bpt->inserted
11054881
KH
3205 && bpt->type != bp_hardware_watchpoint
3206 && bpt->type != bp_read_watchpoint
3207 && bpt->type != bp_access_watchpoint)
fe675038
JK
3208 {
3209 ALL_BREAKPOINTS (b)
ebad9e90
JK
3210 if (b->address == bpt->address
3211 && !b->duplicate
3212 && b->enable != disabled)
fe675038
JK
3213 {
3214 int val;
3215 val = target_insert_breakpoint (b->address, b->shadow_contents);
3216 if (val != 0)
3217 {
05052b63 3218 target_terminal_ours_for_output ();
199b2450 3219 fprintf_unfiltered (gdb_stderr, "Cannot insert breakpoint %d:\n", b->number);
fe675038
JK
3220 memory_error (val, b->address); /* which bombs us out */
3221 }
3222 else
3223 b->inserted = 1;
3224 }
3225 }
bd5635a1
RP
3226
3227 free_command_lines (&bpt->commands);
3228 if (bpt->cond)
d889f6b7 3229 free (bpt->cond);
bd5635a1 3230 if (bpt->cond_string != NULL)
d889f6b7 3231 free (bpt->cond_string);
bd5635a1 3232 if (bpt->addr_string != NULL)
d889f6b7 3233 free (bpt->addr_string);
0eaaa46a 3234 if (bpt->exp_string != NULL)
d889f6b7
JK
3235 free (bpt->exp_string);
3236 if (bpt->source_file != NULL)
3237 free (bpt->source_file);
bd5635a1 3238
bd5635a1 3239 /* Be sure no bpstat's are pointing at it after it's been freed. */
05052b63
JK
3240 /* FIXME, how can we find all bpstat's?
3241 We just check stop_bpstat for now. */
bd5635a1
RP
3242 for (bs = stop_bpstat; bs; bs = bs->next)
3243 if (bs->breakpoint_at == bpt)
3244 bs->breakpoint_at = NULL;
c8950965 3245 free ((PTR)bpt);
bd5635a1
RP
3246}
3247
bd5635a1
RP
3248static void
3249delete_command (arg, from_tty)
3250 char *arg;
3251 int from_tty;
3252{
3253
3254 if (arg == 0)
3255 {
3256 /* Ask user only if there are some breakpoints to delete. */
3257 if (!from_tty
3258 || (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
3259 {
3260 /* No arg; clear all breakpoints. */
3261 while (breakpoint_chain)
3262 delete_breakpoint (breakpoint_chain);
3263 }
3264 }
3265 else
3266 map_breakpoint_numbers (arg, delete_breakpoint);
3267}
3268
bdbd5f50
JG
3269/* Reset a breakpoint given it's struct breakpoint * BINT.
3270 The value we return ends up being the return value from catch_errors.
3271 Unused in this case. */
3272
3273static int
bd5635a1 3274breakpoint_re_set_one (bint)
bdbd5f50 3275 char *bint;
bd5635a1
RP
3276{
3277 struct breakpoint *b = (struct breakpoint *)bint; /* get past catch_errs */
11054881 3278 struct value *mark;
bd5635a1
RP
3279 int i;
3280 struct symtabs_and_lines sals;
bd5635a1 3281 char *s;
30875e1c 3282 enum enable save_enable;
bd5635a1 3283
80ba48f5 3284 switch (b->type)
bd5635a1 3285 {
80ba48f5 3286 case bp_breakpoint:
11054881 3287 case bp_hardware_breakpoint:
80ba48f5
SG
3288 if (b->addr_string == NULL)
3289 {
3290 /* Anything without a string can't be re-set. */
3291 delete_breakpoint (b);
3292 return 0;
3293 }
30875e1c
SG
3294 /* In case we have a problem, disable this breakpoint. We'll restore
3295 its status if we succeed. */
3296 save_enable = b->enable;
3297 b->enable = disabled;
3298
706dc3ce
JL
3299 set_language (b->language);
3300 input_radix = b->input_radix;
bd5635a1 3301 s = b->addr_string;
d889f6b7 3302 sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0, (char ***)NULL);
bd5635a1
RP
3303 for (i = 0; i < sals.nelts; i++)
3304 {
30875e1c 3305 resolve_sal_pc (&sals.sals[i]);
fee933f1
RP
3306
3307 /* Reparse conditions, they might contain references to the
3308 old symtab. */
3309 if (b->cond_string != NULL)
3310 {
3311 s = b->cond_string;
3312 if (b->cond)
3313 free ((PTR)b->cond);
3314 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
3315 }
3316
3317 /* We need to re-set the breakpoint if the address changes...*/
d889f6b7 3318 if (b->address != sals.sals[i].pc
fee933f1
RP
3319 /* ...or new and old breakpoints both have source files, and
3320 the source file name or the line number changes... */
d889f6b7
JK
3321 || (b->source_file != NULL
3322 && sals.sals[i].symtab != NULL
3323 && (!STREQ (b->source_file, sals.sals[i].symtab->filename)
3324 || b->line_number != sals.sals[i].line)
fee933f1
RP
3325 )
3326 /* ...or we switch between having a source file and not having
3327 one. */
3328 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
3329 )
bd5635a1 3330 {
d889f6b7
JK
3331 if (b->source_file != NULL)
3332 free (b->source_file);
3333 if (sals.sals[i].symtab == NULL)
3334 b->source_file = NULL;
3335 else
3336 b->source_file =
3337 savestring (sals.sals[i].symtab->filename,
3338 strlen (sals.sals[i].symtab->filename));
8537ba60
SG
3339 b->line_number = sals.sals[i].line;
3340 b->address = sals.sals[i].pc;
bd5635a1 3341
8537ba60 3342 check_duplicates (b->address);
bd5635a1 3343
8537ba60 3344 mention (b);
6c803036
JK
3345
3346 /* Might be better to do this just once per breakpoint_re_set,
3347 rather than once for every breakpoint. */
3348 breakpoints_changed ();
8537ba60 3349 }
30875e1c 3350 b->enable = save_enable; /* Restore it, this worked. */
bd5635a1 3351 }
c8950965 3352 free ((PTR)sals.sals);
80ba48f5 3353 break;
2d313932 3354
80ba48f5 3355 case bp_watchpoint:
999dd04b 3356 case bp_hardware_watchpoint:
11054881
KH
3357 case bp_read_watchpoint:
3358 case bp_access_watchpoint:
0eaaa46a 3359 innermost_block = NULL;
0a97f6c4
JK
3360 /* The issue arises of what context to evaluate this in. The same
3361 one as when it was set, but what does that mean when symbols have
3362 been re-read? We could save the filename and functionname, but
3363 if the context is more local than that, the best we could do would
3364 be something like how many levels deep and which index at that
3365 particular level, but that's going to be less stable than filenames
3366 or functionnames. */
3367 /* So for now, just use a global context. */
0eaaa46a
JK
3368 b->exp = parse_expression (b->exp_string);
3369 b->exp_valid_block = innermost_block;
11054881 3370 mark = value_mark ();
0eaaa46a
JK
3371 b->val = evaluate_expression (b->exp);
3372 release_value (b->val);
3373 if (VALUE_LAZY (b->val))
3374 value_fetch_lazy (b->val);
3375
2d313932
JK
3376 if (b->cond_string != NULL)
3377 {
3378 s = b->cond_string;
3379 b->cond = parse_exp_1 (&s, (struct block *)0, 0);
3380 }
cabd4da6
JK
3381 if (b->enable == enabled)
3382 mention (b);
11054881 3383 value_free_to_mark (mark);
80ba48f5 3384 break;
2d313932 3385
80ba48f5
SG
3386 default:
3387 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
2d313932 3388 /* fall through */
80ba48f5
SG
3389 case bp_until:
3390 case bp_finish:
3391 case bp_longjmp:
3392 case bp_longjmp_resume:
999dd04b 3393 case bp_watchpoint_scope:
cf3e377e 3394 case bp_call_dummy:
80ba48f5
SG
3395 delete_breakpoint (b);
3396 break;
bd5635a1 3397 }
80ba48f5 3398
bdbd5f50 3399 return 0;
bd5635a1
RP
3400}
3401
3402/* Re-set all breakpoints after symbols have been re-loaded. */
3403void
3404breakpoint_re_set ()
3405{
cba0d141 3406 struct breakpoint *b, *temp;
706dc3ce
JL
3407 enum language save_language;
3408 int save_input_radix;
30875e1c
SG
3409 static char message1[] = "Error in re-setting breakpoint %d:\n";
3410 char message[sizeof (message1) + 30 /* slop */];
bd5635a1 3411
706dc3ce
JL
3412 save_language = current_language->la_language;
3413 save_input_radix = input_radix;
cba0d141 3414 ALL_BREAKPOINTS_SAFE (b, temp)
bd5635a1 3415 {
2d313932 3416 sprintf (message, message1, b->number); /* Format possible error msg */
fe675038
JK
3417 catch_errors (breakpoint_re_set_one, (char *) b, message,
3418 RETURN_MASK_ALL);
bd5635a1 3419 }
706dc3ce
JL
3420 set_language (save_language);
3421 input_radix = save_input_radix;
bd5635a1 3422
80ba48f5
SG
3423 create_longjmp_breakpoint("longjmp");
3424 create_longjmp_breakpoint("_longjmp");
3425 create_longjmp_breakpoint("siglongjmp");
3426 create_longjmp_breakpoint(NULL);
3427
1eeba686
PB
3428#if 0
3429 /* Took this out (temporaliy at least), since it produces an extra
3430 blank line at startup. This messes up the gdbtests. -PB */
bd5635a1
RP
3431 /* Blank line to finish off all those mention() messages we just printed. */
3432 printf_filtered ("\n");
1eeba686 3433#endif
bd5635a1
RP
3434}
3435\f
3436/* Set ignore-count of breakpoint number BPTNUM to COUNT.
3437 If from_tty is nonzero, it prints a message to that effect,
3438 which ends with a period (no newline). */
3439
3440void
3441set_ignore_count (bptnum, count, from_tty)
3442 int bptnum, count, from_tty;
3443{
3444 register struct breakpoint *b;
3445
3446 if (count < 0)
3447 count = 0;
3448
3449 ALL_BREAKPOINTS (b)
3450 if (b->number == bptnum)
3451 {
3452 b->ignore_count = count;
3453 if (!from_tty)
3454 return;
3455 else if (count == 0)
423e9664
SG
3456 printf_filtered ("Will stop next time breakpoint %d is reached.",
3457 bptnum);
bd5635a1 3458 else if (count == 1)
423e9664
SG
3459 printf_filtered ("Will ignore next crossing of breakpoint %d.",
3460 bptnum);
bd5635a1 3461 else
423e9664 3462 printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
bd5635a1 3463 count, bptnum);
6c803036 3464 breakpoints_changed ();
bd5635a1
RP
3465 return;
3466 }
3467
3468 error ("No breakpoint number %d.", bptnum);
3469}
3470
3471/* Clear the ignore counts of all breakpoints. */
3472void
3473breakpoint_clear_ignore_counts ()
3474{
3475 struct breakpoint *b;
3476
3477 ALL_BREAKPOINTS (b)
3478 b->ignore_count = 0;
3479}
3480
3481/* Command to set ignore-count of breakpoint N to COUNT. */
3482
3483static void
3484ignore_command (args, from_tty)
3485 char *args;
3486 int from_tty;
3487{
3488 char *p = args;
3489 register int num;
3490
3491 if (p == 0)
3492 error_no_arg ("a breakpoint number");
3493
3494 num = get_number (&p);
3495
3496 if (*p == 0)
3497 error ("Second argument (specified ignore-count) is missing.");
3498
bdbd5f50
JG
3499 set_ignore_count (num,
3500 longest_to_int (value_as_long (parse_and_eval (p))),
3501 from_tty);
423e9664 3502 printf_filtered ("\n");
6c803036 3503 breakpoints_changed ();
bd5635a1
RP
3504}
3505\f
3506/* Call FUNCTION on each of the breakpoints
3507 whose numbers are given in ARGS. */
3508
3509static void
3510map_breakpoint_numbers (args, function)
3511 char *args;
30875e1c 3512 void (*function) PARAMS ((struct breakpoint *));
bd5635a1
RP
3513{
3514 register char *p = args;
3515 char *p1;
3516 register int num;
3517 register struct breakpoint *b;
3518
3519 if (p == 0)
3520 error_no_arg ("one or more breakpoint numbers");
3521
3522 while (*p)
3523 {
3524 p1 = p;
3525
3526 num = get_number (&p1);
3527
3528 ALL_BREAKPOINTS (b)
3529 if (b->number == num)
3530 {
999dd04b 3531 struct breakpoint *related_breakpoint = b->related_breakpoint;
bd5635a1 3532 function (b);
999dd04b
JL
3533 if (related_breakpoint)
3534 function (related_breakpoint);
bd5635a1
RP
3535 goto win;
3536 }
199b2450 3537 printf_unfiltered ("No breakpoint number %d.\n", num);
bd5635a1
RP
3538 win:
3539 p = p1;
3540 }
3541}
3542
3543static void
3544enable_breakpoint (bpt)
3545 struct breakpoint *bpt;
3546{
706dc3ce 3547 struct frame_info *save_selected_frame = NULL;
fa99ebe1 3548 int save_selected_frame_level = -1;
11054881
KH
3549 int target_resources_ok, other_type_used;
3550 struct value *mark;
fa99ebe1 3551
754e5da2
SG
3552 if (enable_breakpoint_hook)
3553 enable_breakpoint_hook (bpt);
3554
11054881
KH
3555 if (bpt->type == bp_hardware_breakpoint)
3556 {
3557 int i;
3558 i = hw_breakpoint_used_count();
3559 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3560 bp_hardware_breakpoint, i+1, 0);
3561 if (target_resources_ok == 0)
3562 error ("No hardware breakpoint support in the target.");
3563 else if (target_resources_ok < 0)
3564 error ("Hardware breakpoints used exceeds limit.");
3565 }
bd5635a1 3566 bpt->enable = enabled;
bd5635a1 3567 check_duplicates (bpt->address);
11054881
KH
3568
3569 if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint ||
3570 bpt->type == bp_read_watchpoint || bpt->type == bp_access_watchpoint)
bd5635a1 3571 {
fa99ebe1 3572 if (bpt->exp_valid_block != NULL)
f266e564 3573 {
706dc3ce
JL
3574 struct frame_info *fr =
3575 find_frame_addr_in_frame_chain (bpt->watchpoint_frame);
fa99ebe1
JK
3576 if (fr == NULL)
3577 {
3578 printf_filtered ("\
f266e564
JK
3579Cannot enable watchpoint %d because the block in which its expression\n\
3580is valid is not currently in scope.\n", bpt->number);
fa99ebe1
JK
3581 bpt->enable = disabled;
3582 return;
3583 }
999dd04b 3584
fa99ebe1
JK
3585 save_selected_frame = selected_frame;
3586 save_selected_frame_level = selected_frame_level;
3587 select_frame (fr, -1);
f266e564
JK
3588 }
3589
bd5635a1 3590 value_free (bpt->val);
11054881 3591 mark = value_mark ();
bd5635a1
RP
3592 bpt->val = evaluate_expression (bpt->exp);
3593 release_value (bpt->val);
2d313932
JK
3594 if (VALUE_LAZY (bpt->val))
3595 value_fetch_lazy (bpt->val);
fa99ebe1 3596
11054881
KH
3597 if (bpt->type == bp_hardware_watchpoint ||
3598 bpt->type == bp_read_watchpoint ||
3599 bpt->type == bp_access_watchpoint)
3600 {
3601 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
557f3a0e
SS
3602 int mem_cnt = can_use_hardware_watchpoint (bpt->val);
3603
11054881 3604 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
557f3a0e 3605 bpt->type, i + mem_cnt, other_type_used);
11054881
KH
3606 /* we can consider of type is bp_hardware_watchpoint, convert to
3607 bp_watchpoint in the following condition */
3608 if (target_resources_ok < 0)
3609 {
3610 printf_filtered("\
3611Cannot enable watchpoint %d because target watch resources\n\
3612have been allocated for other watchpoints.\n", bpt->number);
3613 bpt->enable = disabled;
3614 value_free_to_mark (mark);
3615 return;
3616 }
3617 }
3618
fa99ebe1
JK
3619 if (save_selected_frame_level >= 0)
3620 select_frame (save_selected_frame, save_selected_frame_level);
11054881 3621 value_free_to_mark (mark);
bd5635a1
RP
3622 }
3623}
3624
bdbd5f50 3625/* ARGSUSED */
bd5635a1
RP
3626static void
3627enable_command (args, from_tty)
3628 char *args;
3629 int from_tty;
3630{
3631 struct breakpoint *bpt;
3632 if (args == 0)
3633 ALL_BREAKPOINTS (bpt)
423e9664
SG
3634 switch (bpt->type)
3635 {
3636 case bp_breakpoint:
11054881 3637 case bp_hardware_breakpoint:
423e9664 3638 case bp_watchpoint:
999dd04b 3639 case bp_hardware_watchpoint:
11054881
KH
3640 case bp_read_watchpoint:
3641 case bp_access_watchpoint:
423e9664
SG
3642 enable_breakpoint (bpt);
3643 default:
3644 continue;
3645 }
bd5635a1
RP
3646 else
3647 map_breakpoint_numbers (args, enable_breakpoint);
3648}
3649
3650static void
3651disable_breakpoint (bpt)
3652 struct breakpoint *bpt;
3653{
999dd04b
JL
3654 /* Never disable a watchpoint scope breakpoint; we want to
3655 hit them when we leave scope so we can delete both the
3656 watchpoint and its scope breakpoint at that time. */
3657 if (bpt->type == bp_watchpoint_scope)
3658 return;
3659
754e5da2
SG
3660 if (disable_breakpoint_hook)
3661 disable_breakpoint_hook (bpt);
3662
bd5635a1
RP
3663 bpt->enable = disabled;
3664
bd5635a1
RP
3665 check_duplicates (bpt->address);
3666}
3667
bdbd5f50 3668/* ARGSUSED */
bd5635a1
RP
3669static void
3670disable_command (args, from_tty)
3671 char *args;
3672 int from_tty;
3673{
3674 register struct breakpoint *bpt;
3675 if (args == 0)
3676 ALL_BREAKPOINTS (bpt)
423e9664
SG
3677 switch (bpt->type)
3678 {
3679 case bp_breakpoint:
11054881
KH
3680 case bp_hardware_breakpoint:
3681 case bp_watchpoint:
3682 case bp_hardware_watchpoint:
3683 case bp_read_watchpoint:
3684 case bp_access_watchpoint:
423e9664
SG
3685 disable_breakpoint (bpt);
3686 default:
3687 continue;
3688 }
bd5635a1
RP
3689 else
3690 map_breakpoint_numbers (args, disable_breakpoint);
3691}
3692
3693static void
3694enable_once_breakpoint (bpt)
3695 struct breakpoint *bpt;
3696{
706dc3ce 3697 struct frame_info *save_selected_frame = NULL;
11054881
KH
3698 int save_selected_frame_level = -1;
3699 int target_resources_ok, other_type_used;
3700 struct value *mark;
3701
3702 if (bpt->type == bp_hardware_breakpoint)
3703 {
3704 int i;
3705 i = hw_breakpoint_used_count();
3706 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3707 bp_hardware_breakpoint, i+1, 0);
3708 if (target_resources_ok == 0)
3709 error ("No hardware breakpoint support in the target.");
3710 else if (target_resources_ok < 0)
3711 error ("Hardware breakpoints used exceeds limit.");
3712 }
3713
30875e1c
SG
3714 bpt->enable = enabled;
3715 bpt->disposition = disable;
bd5635a1 3716 check_duplicates (bpt->address);
6c803036 3717 breakpoints_changed ();
11054881
KH
3718
3719 if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint ||
3720 bpt->type == bp_read_watchpoint || bpt->type == bp_access_watchpoint)
3721 {
3722 if (bpt->exp_valid_block != NULL)
3723 {
706dc3ce
JL
3724 struct frame_info *fr =
3725 find_frame_addr_in_frame_chain (bpt->watchpoint_frame);
11054881
KH
3726 if (fr == NULL)
3727 {
3728 printf_filtered ("\
3729Cannot enable watchpoint %d because the block in which its expression\n\
3730is valid is not currently in scope.\n", bpt->number);
3731 bpt->enable = disabled;
3732 return;
3733 }
3734
3735 save_selected_frame = selected_frame;
3736 save_selected_frame_level = selected_frame_level;
3737 select_frame (fr, -1);
3738 }
3739
3740 value_free (bpt->val);
3741 mark = value_mark ();
3742 bpt->val = evaluate_expression (bpt->exp);
3743 release_value (bpt->val);
3744 if (VALUE_LAZY (bpt->val))
3745 value_fetch_lazy (bpt->val);
3746
3747 if (bpt->type == bp_hardware_watchpoint ||
3748 bpt->type == bp_read_watchpoint ||
3749 bpt->type == bp_access_watchpoint)
3750 {
3751 int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
3752 int mem_cnt = can_use_hardware_watchpoint(bpt->val);
3753 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3754 bpt->type, i+mem_cnt, other_type_used);
3755 /* we can consider of type is bp_hardware_watchpoint, convert to
3756 bp_watchpoint in the following condition */
3757 if (target_resources_ok < 0)
3758 {
3759 printf_filtered("\
3760Cannot enable watchpoint %d because target watch resources\n\
3761have been allocated for other watchpoints.\n", bpt->number);
3762 bpt->enable = disabled;
3763 value_free_to_mark (mark);
3764 }
3765 }
3766
3767 if (save_selected_frame_level >= 0)
3768 select_frame (save_selected_frame, save_selected_frame_level);
3769 value_free_to_mark (mark);
3770 }
bd5635a1
RP
3771}
3772
bdbd5f50 3773/* ARGSUSED */
bd5635a1
RP
3774static void
3775enable_once_command (args, from_tty)
3776 char *args;
3777 int from_tty;
3778{
3779 map_breakpoint_numbers (args, enable_once_breakpoint);
3780}
3781
3782static void
3783enable_delete_breakpoint (bpt)
3784 struct breakpoint *bpt;
3785{
30875e1c
SG
3786 bpt->enable = enabled;
3787 bpt->disposition = delete;
bd5635a1
RP
3788
3789 check_duplicates (bpt->address);
6c803036 3790 breakpoints_changed ();
bd5635a1
RP
3791}
3792
bdbd5f50 3793/* ARGSUSED */
bd5635a1
RP
3794static void
3795enable_delete_command (args, from_tty)
3796 char *args;
3797 int from_tty;
3798{
3799 map_breakpoint_numbers (args, enable_delete_breakpoint);
3800}
3801\f
706dc3ce
JL
3802/* Use default_breakpoint_'s, or nothing if they aren't valid. */
3803
bd5635a1
RP
3804struct symtabs_and_lines
3805decode_line_spec_1 (string, funfirstline)
3806 char *string;
3807 int funfirstline;
3808{
3809 struct symtabs_and_lines sals;
3810 if (string == 0)
3811 error ("Empty line specification.");
3812 if (default_breakpoint_valid)
3813 sals = decode_line_1 (&string, funfirstline,
d889f6b7
JK
3814 default_breakpoint_symtab, default_breakpoint_line,
3815 (char ***)NULL);
bd5635a1 3816 else
d889f6b7
JK
3817 sals = decode_line_1 (&string, funfirstline,
3818 (struct symtab *)NULL, 0, (char ***)NULL);
bd5635a1
RP
3819 if (*string)
3820 error ("Junk at end of line specification: %s", string);
3821 return sals;
3822}
3823\f
bd5635a1
RP
3824void
3825_initialize_breakpoint ()
3826{
3827 breakpoint_chain = 0;
3828 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
3829 before a breakpoint is set. */
3830 breakpoint_count = 0;
3831
3832 add_com ("ignore", class_breakpoint, ignore_command,
557f3a0e
SS
3833 "Set ignore-count of breakpoint number N to COUNT.\n\
3834Usage is `ignore N COUNT'.");
bd5635a1
RP
3835
3836 add_com ("commands", class_breakpoint, commands_command,
3837 "Set commands to be executed when a breakpoint is hit.\n\
3838Give breakpoint number as argument after \"commands\".\n\
3839With no argument, the targeted breakpoint is the last one set.\n\
3840The commands themselves follow starting on the next line.\n\
3841Type a line containing \"end\" to indicate the end of them.\n\
3842Give \"silent\" as the first line to make the breakpoint silent;\n\
3843then no output is printed when it is hit, except what the commands print.");
3844
3845 add_com ("condition", class_breakpoint, condition_command,
3846 "Specify breakpoint number N to break only if COND is true.\n\
557f3a0e
SS
3847Usage is `condition N COND', where N is an integer and COND is an\n\
3848expression to be evaluated whenever breakpoint N is reached. ");
bd5635a1
RP
3849
3850 add_com ("tbreak", class_breakpoint, tbreak_command,
3851 "Set a temporary breakpoint. Args like \"break\" command.\n\
c4de6b30
JK
3852Like \"break\" except the breakpoint is only temporary,\n\
3853so it will be deleted when hit. Equivalent to \"break\" followed\n\
3854by using \"enable delete\" on the breakpoint number.");
bd5635a1 3855
11054881
KH
3856 add_com ("hbreak", class_breakpoint, hbreak_command,
3857 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
3858Like \"break\" except the breakpoint requires hardware support,\n\
3859some target hardware may not have this support.");
3860
3861 add_com ("thbreak", class_breakpoint, thbreak_command,
3862 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
3863Like \"hbreak\" except the breakpoint is only temporary,\n\
3864so it will be deleted when hit.");
3865
bd5635a1
RP
3866 add_prefix_cmd ("enable", class_breakpoint, enable_command,
3867 "Enable some breakpoints.\n\
3868Give breakpoint numbers (separated by spaces) as arguments.\n\
3869With no subcommand, breakpoints are enabled until you command otherwise.\n\
3870This is used to cancel the effect of the \"disable\" command.\n\
3871With a subcommand you can enable temporarily.",
3872 &enablelist, "enable ", 1, &cmdlist);
3873
3874 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
3875 "Enable some breakpoints.\n\
3876Give breakpoint numbers (separated by spaces) as arguments.\n\
3877This is used to cancel the effect of the \"disable\" command.\n\
3878May be abbreviated to simply \"enable\".\n",
3879 &enablebreaklist, "enable breakpoints ", 1, &enablelist);
3880
3881 add_cmd ("once", no_class, enable_once_command,
3882 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
bd2f0c85 3883If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
bd5635a1
RP
3884 &enablebreaklist);
3885
3886 add_cmd ("delete", no_class, enable_delete_command,
3887 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3888If a breakpoint is hit while enabled in this fashion, it is deleted.",
3889 &enablebreaklist);
3890
3891 add_cmd ("delete", no_class, enable_delete_command,
3892 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
3893If a breakpoint is hit while enabled in this fashion, it is deleted.",
3894 &enablelist);
3895
3896 add_cmd ("once", no_class, enable_once_command,
3897 "Enable breakpoints for one hit. Give breakpoint numbers.\n\
bd2f0c85 3898If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
bd5635a1
RP
3899 &enablelist);
3900
3901 add_prefix_cmd ("disable", class_breakpoint, disable_command,
3902 "Disable some breakpoints.\n\
3903Arguments are breakpoint numbers with spaces in between.\n\
3904To disable all breakpoints, give no argument.\n\
3905A disabled breakpoint is not forgotten, but has no effect until reenabled.",
3906 &disablelist, "disable ", 1, &cmdlist);
3907 add_com_alias ("dis", "disable", class_breakpoint, 1);
3908 add_com_alias ("disa", "disable", class_breakpoint, 1);
3909
3910 add_cmd ("breakpoints", class_alias, disable_command,
3911 "Disable some breakpoints.\n\
3912Arguments are breakpoint numbers with spaces in between.\n\
3913To disable all breakpoints, give no argument.\n\
3914A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
3915This command may be abbreviated \"disable\".",
3916 &disablelist);
3917
3918 add_prefix_cmd ("delete", class_breakpoint, delete_command,
3919 "Delete some breakpoints or auto-display expressions.\n\
3920Arguments are breakpoint numbers with spaces in between.\n\
3921To delete all breakpoints, give no argument.\n\
3922\n\
3923Also a prefix command for deletion of other GDB objects.\n\
3924The \"unset\" command is also an alias for \"delete\".",
3925 &deletelist, "delete ", 1, &cmdlist);
3926 add_com_alias ("d", "delete", class_breakpoint, 1);
bd5635a1
RP
3927
3928 add_cmd ("breakpoints", class_alias, delete_command,
3929 "Delete some breakpoints or auto-display expressions.\n\
3930Arguments are breakpoint numbers with spaces in between.\n\
3931To delete all breakpoints, give no argument.\n\
3932This command may be abbreviated \"delete\".",
3933 &deletelist);
3934
3935 add_com ("clear", class_breakpoint, clear_command,
706dc3ce 3936 concat ("Clear breakpoint at specified line or function.\n\
bd5635a1
RP
3937Argument may be line number, function name, or \"*\" and an address.\n\
3938If line number is specified, all breakpoints in that line are cleared.\n\
3939If function is specified, breakpoints at beginning of function are cleared.\n\
706dc3ce
JL
3940If an address is specified, breakpoints at that address are cleared.\n\n",
3941"With no argument, clears all breakpoints in the line that the selected frame\n\
bd5635a1
RP
3942is executing in.\n\
3943\n\
706dc3ce 3944See also the \"delete\" command which clears breakpoints by number.", NULL));
bd5635a1
RP
3945
3946 add_com ("break", class_breakpoint, break_command,
706dc3ce 3947 concat ("Set breakpoint at specified line or function.\n\
bd5635a1
RP
3948Argument may be line number, function name, or \"*\" and an address.\n\
3949If line number is specified, break at start of code for that line.\n\
3950If function is specified, break at start of code for that function.\n\
706dc3ce
JL
3951If an address is specified, break at that exact address.\n",
3952"With no arg, uses current execution address of selected stack frame.\n\
bd5635a1
RP
3953This is useful for breaking on return to a stack frame.\n\
3954\n\
3955Multiple breakpoints at one place are permitted, and useful if conditional.\n\
3956\n\
706dc3ce 3957Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
bd5635a1
RP
3958 add_com_alias ("b", "break", class_run, 1);
3959 add_com_alias ("br", "break", class_run, 1);
3960 add_com_alias ("bre", "break", class_run, 1);
3961 add_com_alias ("brea", "break", class_run, 1);
3962
3963 add_info ("breakpoints", breakpoints_info,
706dc3ce 3964 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
80ba48f5 3965The \"Type\" column indicates one of:\n\
423e9664
SG
3966\tbreakpoint - normal breakpoint\n\
3967\twatchpoint - watchpoint\n\
80ba48f5
SG
3968The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3969the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3970breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
706dc3ce
JL
3971address and file/line number respectively.\n\n",
3972"Convenience variable \"$_\" and default examine address for \"x\"\n\
80ba48f5
SG
3973are set to the address of the last breakpoint listed.\n\n\
3974Convenience variable \"$bpnum\" contains the number of the last\n\
706dc3ce 3975breakpoint set.", NULL));
80ba48f5 3976
9b280a7f
JG
3977#if MAINTENANCE_CMDS
3978
3979 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
706dc3ce 3980 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
80ba48f5 3981The \"Type\" column indicates one of:\n\
423e9664
SG
3982\tbreakpoint - normal breakpoint\n\
3983\twatchpoint - watchpoint\n\
3984\tlongjmp - internal breakpoint used to step through longjmp()\n\
3985\tlongjmp resume - internal breakpoint at the target of longjmp()\n\
3986\tuntil - internal breakpoint used by the \"until\" command\n\
706dc3ce
JL
3987\tfinish - internal breakpoint used by the \"finish\" command\n",
3988"The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
80ba48f5
SG
3989the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
3990breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
706dc3ce
JL
3991address and file/line number respectively.\n\n",
3992"Convenience variable \"$_\" and default examine address for \"x\"\n\
bd5635a1
RP
3993are set to the address of the last breakpoint listed.\n\n\
3994Convenience variable \"$bpnum\" contains the number of the last\n\
706dc3ce 3995breakpoint set.", NULL),
9b280a7f
JG
3996 &maintenanceinfolist);
3997
3998#endif /* MAINTENANCE_CMDS */
bd5635a1
RP
3999
4000 add_com ("catch", class_breakpoint, catch_command,
4001 "Set breakpoints to catch exceptions that are raised.\n\
4002Argument may be a single exception to catch, multiple exceptions\n\
4003to catch, or the default exception \"default\". If no arguments\n\
4004are given, breakpoints are set at all exception handlers catch clauses\n\
4005within the current scope.\n\
4006\n\
4007A condition specified for the catch applies to all breakpoints set\n\
4008with this command\n\
4009\n\
4010Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
4011
4012 add_com ("watch", class_breakpoint, watch_command,
4013 "Set a watchpoint for an expression.\n\
4014A watchpoint stops execution of your program whenever the value of\n\
4015an expression changes.");
4016
11054881
KH
4017 add_com ("rwatch", class_breakpoint, rwatch_command,
4018 "Set a read watchpoint for an expression.\n\
4019A watchpoint stops execution of your program whenever the value of\n\
4020an expression is read.");
4021
4022 add_com ("awatch", class_breakpoint, awatch_command,
4023 "Set a watchpoint for an expression.\n\
4024A watchpoint stops execution of your program whenever the value of\n\
4025an expression is either read or written.");
4026
c8950965
JG
4027 add_info ("watchpoints", breakpoints_info,
4028 "Synonym for ``info breakpoints''.");
9f577285 4029
bd5635a1 4030}
1eeba686 4031
2d313932
JK
4032/* OK, when we call objfile_relocate, we need to relocate breakpoints
4033 too. breakpoint_re_set is not a good choice--for example, if
4034 addr_string contains just a line number without a file name the
4035 breakpoint might get set in a different file. In general, there is
4036 no need to go all the way back to the user's string (though this might
4037 work if some effort were made to canonicalize it), since symtabs and
4038 everything except addresses are still valid.
1eeba686 4039
2d313932
JK
4040 Probably the best way to solve this is to have each breakpoint save
4041 the objfile and the section number that was used to set it (if set
4042 by "*addr", probably it is best to use find_pc_line to get a symtab
4043 and use the objfile and block_line_section for that symtab). Then
4044 objfile_relocate can call fixup_breakpoints with the objfile and
4045 the new_offsets, and it can relocate only the appropriate breakpoints. */
1eeba686 4046
2d313932
JK
4047#ifdef IBM6000_TARGET
4048/* But for now, just kludge it based on the concept that before an
4049 objfile is relocated the breakpoint is below 0x10000000, and afterwards
4050 it is higher, so that way we only relocate each breakpoint once. */
1eeba686 4051
1eeba686
PB
4052void
4053fixup_breakpoints (low, high, delta)
4054 CORE_ADDR low;
4055 CORE_ADDR high;
4056 CORE_ADDR delta;
4057{
4058 struct breakpoint *b;
1eeba686
PB
4059
4060 ALL_BREAKPOINTS (b)
4061 {
4062 if (b->address >= low && b->address <= high)
4063 b->address += delta;
4064 }
4065}
4066#endif
This page took 0.360413 seconds and 4 git commands to generate.