Fetch lazy values
[platform/upstream/binutils.git] / gdb / breakpoint.c
1 /* Everything about breakpoints, for GDB.
2    Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
19
20 #include "defs.h"
21 #include <ctype.h>
22 #include "symtab.h"
23 #include "frame.h"
24 #include "breakpoint.h"
25 #include "gdbtypes.h"
26 #include "expression.h"
27 #include "gdbcore.h"
28 #include "gdbcmd.h"
29 #include "value.h"
30 #include "ctype.h"
31 #include "command.h"
32 #include "inferior.h"
33 #include "target.h"
34 #include "language.h"
35 #include <string.h>
36 #include "demangle.h"
37
38 /* local function prototypes */
39
40 static void
41 catch_command_1 PARAMS ((char *, int, int));
42
43 static void
44 enable_delete_command PARAMS ((char *, int));
45
46 static void
47 enable_delete_breakpoint PARAMS ((struct breakpoint *));
48
49 static void
50 enable_once_command PARAMS ((char *, int));
51
52 static void
53 enable_once_breakpoint PARAMS ((struct breakpoint *));
54
55 static void
56 disable_command PARAMS ((char *, int));
57
58 static void
59 disable_breakpoint PARAMS ((struct breakpoint *));
60
61 static void
62 enable_command PARAMS ((char *, int));
63
64 static void
65 enable_breakpoint PARAMS ((struct breakpoint *));
66
67 static void
68 map_breakpoint_numbers PARAMS ((char *, void (*)(struct breakpoint *)));
69
70 static void
71 ignore_command PARAMS ((char *, int));
72
73 static int
74 breakpoint_re_set_one PARAMS ((char *));
75
76 static void
77 delete_command PARAMS ((char *, int));
78
79 static void
80 clear_command PARAMS ((char *, int));
81
82 static void
83 catch_command PARAMS ((char *, int));
84
85 static struct symtabs_and_lines
86 get_catch_sals PARAMS ((int));
87
88 static void
89 watch_command PARAMS ((char *, int));
90
91 static void
92 tbreak_command PARAMS ((char *, int));
93
94 static void
95 break_command_1 PARAMS ((char *, int, int));
96
97 static void
98 mention PARAMS ((struct breakpoint *));
99
100 static struct breakpoint *
101 set_raw_breakpoint PARAMS ((struct symtab_and_line));
102
103 static void
104 check_duplicates PARAMS ((CORE_ADDR));
105
106 static void
107 describe_other_breakpoints PARAMS ((CORE_ADDR));
108
109 static void
110 breakpoints_info PARAMS ((char *, int));
111
112 static void
113 breakpoint_1 PARAMS ((int, int));
114
115 static bpstat
116 bpstat_alloc PARAMS ((struct breakpoint *, bpstat));
117
118 static int
119 breakpoint_cond_eval PARAMS ((char *));
120
121 static void
122 cleanup_executing_breakpoints PARAMS ((int));
123
124 static void
125 commands_command PARAMS ((char *, int));
126
127 static void
128 condition_command PARAMS ((char *, int));
129
130 static int
131 get_number PARAMS ((char **));
132
133 static void
134 set_breakpoint_count PARAMS ((int));
135
136
137 extern int addressprint;                /* Print machine addresses? */
138 extern int demangle;                    /* Print de-mangled symbol names? */
139
140 /* Are we executing breakpoint commands?  */
141 static int executing_breakpoint_commands;
142
143 /* Walk the following statement or block through all breakpoints.
144    ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
145    breakpoint.  */
146
147 #define ALL_BREAKPOINTS(b)  for (b = breakpoint_chain; b; b = b->next)
148
149 #define ALL_BREAKPOINTS_SAFE(b,tmp)     \
150         for (b = breakpoint_chain;      \
151              b? (tmp=b->next, 1): 0;    \
152              b = tmp)
153
154 /* Chain of all breakpoints defined.  */
155
156 struct breakpoint *breakpoint_chain;
157
158 /* Number of last breakpoint made.  */
159
160 static int breakpoint_count;
161
162 /* Set breakpoint count to NUM.  */
163 static void
164 set_breakpoint_count (num)
165      int num;
166 {
167   breakpoint_count = num;
168   set_internalvar (lookup_internalvar ("bpnum"),
169                    value_from_longest (builtin_type_int, (LONGEST) num));
170 }
171
172 /* Default address, symtab and line to put a breakpoint at
173    for "break" command with no arg.
174    if default_breakpoint_valid is zero, the other three are
175    not valid, and "break" with no arg is an error.
176
177    This set by print_stack_frame, which calls set_default_breakpoint.  */
178
179 int default_breakpoint_valid;
180 CORE_ADDR default_breakpoint_address;
181 struct symtab *default_breakpoint_symtab;
182 int default_breakpoint_line;
183
184 /* Flag indicating extra verbosity for xgdb.  */
185 extern int xgdb_verbose;
186 \f
187 /* *PP is a string denoting a breakpoint.  Get the number of the breakpoint.
188    Advance *PP after the string and any trailing whitespace.
189
190    Currently the string can either be a number or "$" followed by the name
191    of a convenience variable.  Making it an expression wouldn't work well
192    for map_breakpoint_numbers (e.g. "4 + 5 + 6").  */
193 static int
194 get_number (pp)
195      char **pp;
196 {
197   int retval;
198   char *p = *pp;
199
200   if (p == NULL)
201     /* Empty line means refer to the last breakpoint.  */
202     return breakpoint_count;
203   else if (*p == '$')
204     {
205       /* Make a copy of the name, so we can null-terminate it
206          to pass to lookup_internalvar().  */
207       char *varname;
208       char *start = ++p;
209       value val;
210
211       while (isalnum (*p) || *p == '_')
212         p++;
213       varname = (char *) alloca (p - start + 1);
214       strncpy (varname, start, p - start);
215       varname[p - start] = '\0';
216       val = value_of_internalvar (lookup_internalvar (varname));
217       if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_INT)
218         error (
219 "Convenience variables used to specify breakpoints must have integer values."
220                );
221       retval = (int) value_as_long (val);
222     }
223   else
224     {
225       if (*p == '-')
226         ++p;
227       while (*p >= '0' && *p <= '9')
228         ++p;
229       if (p == *pp)
230         /* There is no number here.  (e.g. "cond a == b").  */
231         error_no_arg ("breakpoint number");
232       retval = atoi (*pp);
233     }
234   if (!(isspace (*p) || *p == '\0'))
235     error ("breakpoint number expected");
236   while (isspace (*p))
237     p++;
238   *pp = p;
239   return retval;
240 }
241 \f
242 /* condition N EXP -- set break condition of breakpoint N to EXP.  */
243
244 static void
245 condition_command (arg, from_tty)
246      char *arg;
247      int from_tty;
248 {
249   register struct breakpoint *b;
250   char *p;
251   register int bnum;
252
253   if (arg == 0)
254     error_no_arg ("breakpoint number");
255
256   p = arg;
257   bnum = get_number (&p);
258
259   ALL_BREAKPOINTS (b)
260     if (b->number == bnum)
261       {
262         if (b->cond)
263           {
264             free ((PTR)b->cond);
265             b->cond = 0;
266           }
267         if (b->cond_string != NULL)
268           free ((PTR)b->cond_string);
269
270         if (*p == 0)
271           {
272             b->cond = 0;
273             b->cond_string = NULL;
274             if (from_tty)
275               printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
276           }
277         else
278           {
279             arg = p;
280             /* I don't know if it matters whether this is the string the user
281                typed in or the decompiled expression.  */
282             b->cond_string = savestring (arg, strlen (arg));
283             b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
284             if (*arg)
285               error ("Junk at end of expression");
286           }
287         return;
288       }
289
290   error ("No breakpoint number %d.", bnum);
291 }
292
293 /* ARGSUSED */
294 static void
295 commands_command (arg, from_tty)
296      char *arg;
297      int from_tty;
298 {
299   register struct breakpoint *b;
300   char *p;
301   register int bnum;
302   struct command_line *l;
303
304   /* If we allowed this, we would have problems with when to
305      free the storage, if we change the commands currently
306      being read from.  */
307
308   if (executing_breakpoint_commands)
309     error ("Can't use the \"commands\" command among a breakpoint's commands.");
310
311   p = arg;
312   bnum = get_number (&p);
313   if (p && *p)
314     error ("Unexpected extra arguments following breakpoint number.");
315       
316   ALL_BREAKPOINTS (b)
317     if (b->number == bnum)
318       {
319         if (from_tty && input_from_terminal_p ())
320           printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
321 End with a line saying just \"end\".\n", bnum);
322         l = read_command_lines ();
323         free_command_lines (&b->commands);
324         b->commands = l;
325         return;
326       }
327   error ("No breakpoint number %d.", bnum);
328 }
329 \f
330 extern int memory_breakpoint_size; /* from mem-break.c */
331
332 /* Like target_read_memory() but if breakpoints are inserted, return
333    the shadow contents instead of the breakpoints themselves.
334
335    Read "memory data" from whatever target or inferior we have. 
336    Returns zero if successful, errno value if not.  EIO is used
337    for address out of bounds.  If breakpoints are inserted, returns
338    shadow contents, not the breakpoints themselves.  From breakpoint.c.  */
339
340 int
341 read_memory_nobpt (memaddr, myaddr, len)
342      CORE_ADDR memaddr;
343      char *myaddr;
344      unsigned len;
345 {
346   int status;
347   struct breakpoint *b;
348
349   if (memory_breakpoint_size < 0)
350     /* No breakpoints on this machine.  */
351     return target_read_memory (memaddr, myaddr, len);
352   
353   ALL_BREAKPOINTS (b)
354     {
355       if (b->type == bp_watchpoint || !b->inserted)
356         continue;
357       else if (b->address + memory_breakpoint_size <= memaddr)
358         /* The breakpoint is entirely before the chunk of memory
359            we are reading.  */
360         continue;
361       else if (b->address >= memaddr + len)
362         /* The breakpoint is entirely after the chunk of memory we
363            are reading.  */
364         continue;
365       else
366         {
367           /* Copy the breakpoint from the shadow contents, and recurse
368              for the things before and after.  */
369           
370           /* Addresses and length of the part of the breakpoint that
371              we need to copy.  */
372           CORE_ADDR membpt = b->address;
373           unsigned int bptlen = memory_breakpoint_size;
374           /* Offset within shadow_contents.  */
375           int bptoffset = 0;
376           
377           if (membpt < memaddr)
378             {
379               /* Only copy the second part of the breakpoint.  */
380               bptlen -= memaddr - membpt;
381               bptoffset = memaddr - membpt;
382               membpt = memaddr;
383             }
384
385           if (membpt + bptlen > memaddr + len)
386             {
387               /* Only copy the first part of the breakpoint.  */
388               bptlen -= (membpt + bptlen) - (memaddr + len);
389             }
390
391           memcpy (myaddr + membpt - memaddr, 
392                   b->shadow_contents + bptoffset, bptlen);
393
394           if (membpt > memaddr)
395             {
396               /* Copy the section of memory before the breakpoint.  */
397               status = read_memory_nobpt (memaddr, myaddr, membpt - memaddr);
398               if (status != 0)
399                 return status;
400             }
401
402           if (membpt + bptlen < memaddr + len)
403             {
404               /* Copy the section of memory after the breakpoint.  */
405               status = read_memory_nobpt
406                 (membpt + bptlen,
407                  myaddr + membpt + bptlen - memaddr,
408                  memaddr + len - (membpt + bptlen));
409               if (status != 0)
410                 return status;
411             }
412           return 0;
413         }
414     }
415   /* Nothing overlaps.  Just call read_memory_noerr.  */
416   return target_read_memory (memaddr, myaddr, len);
417 }
418 \f
419 /* insert_breakpoints is used when starting or continuing the program.
420    remove_breakpoints is used when the program stops.
421    Both return zero if successful,
422    or an `errno' value if could not write the inferior.  */
423
424 int
425 insert_breakpoints ()
426 {
427   register struct breakpoint *b;
428   int val = 0;
429   int disabled_breaks = 0;
430
431   ALL_BREAKPOINTS (b)
432     if (b->type != bp_watchpoint
433         && b->enable != disabled
434         && ! b->inserted
435         && ! b->duplicate)
436       {
437         val = target_insert_breakpoint(b->address, b->shadow_contents);
438         if (val)
439           {
440             /* Can't set the breakpoint.  */
441 #if defined (DISABLE_UNSETTABLE_BREAK)
442             if (DISABLE_UNSETTABLE_BREAK (b->address))
443               {
444                 val = 0;
445                 b->enable = disabled;
446                 if (!disabled_breaks)
447                   {
448                     fprintf (stderr,
449                          "Cannot insert breakpoint %d:\n", b->number);
450                     printf_filtered ("Disabling shared library breakpoints:\n");
451                   }
452                 disabled_breaks = 1;
453                 printf_filtered ("%d ", b->number);
454               }
455             else
456 #endif
457               {
458                 fprintf (stderr, "Cannot insert breakpoint %d:\n", b->number);
459 #ifdef ONE_PROCESS_WRITETEXT
460                 fprintf (stderr,
461                   "The same program may be running in another process.\n");
462 #endif
463                 memory_error (val, b->address); /* which bombs us out */
464               }
465           }
466         else
467           b->inserted = 1;
468       }
469   if (disabled_breaks)
470     printf_filtered ("\n");
471   return val;
472 }
473
474 int
475 remove_breakpoints ()
476 {
477   register struct breakpoint *b;
478   int val;
479
480 #ifdef BREAKPOINT_DEBUG
481   printf ("Removing breakpoints.\n");
482 #endif /* BREAKPOINT_DEBUG */
483
484   ALL_BREAKPOINTS (b)
485     if (b->type != bp_watchpoint && b->inserted)
486       {
487         val = target_remove_breakpoint(b->address, b->shadow_contents);
488         if (val)
489           return val;
490         b->inserted = 0;
491 #ifdef BREAKPOINT_DEBUG
492         printf ("Removed breakpoint at %s",
493                 local_hex_string(b->address));
494         printf (", shadow %s",
495                 local_hex_string(b->shadow_contents[0]));
496         printf (", %s.\n",
497                 local_hex_string(b->shadow_contents[1]));
498 #endif /* BREAKPOINT_DEBUG */
499       }
500
501   return 0;
502 }
503
504 /* Clear the "inserted" flag in all breakpoints.
505    This is done when the inferior is loaded.  */
506
507 void
508 mark_breakpoints_out ()
509 {
510   register struct breakpoint *b;
511
512   ALL_BREAKPOINTS (b)
513     b->inserted = 0;
514 }
515
516 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
517    When continuing from a location with a breakpoint,
518    we actually single step once before calling insert_breakpoints.  */
519
520 int
521 breakpoint_here_p (pc)
522      CORE_ADDR pc;
523 {
524   register struct breakpoint *b;
525
526   ALL_BREAKPOINTS (b)
527     if (b->enable != disabled && b->address == pc)
528       return 1;
529
530   return 0;
531 }
532 \f
533 /* bpstat stuff.  External routines' interfaces are documented
534    in breakpoint.h.  */
535
536 /* Clear a bpstat so that it says we are not at any breakpoint.
537    Also free any storage that is part of a bpstat.  */
538
539 void
540 bpstat_clear (bsp)
541      bpstat *bsp;
542 {
543   bpstat p;
544   bpstat q;
545
546   if (bsp == 0)
547     return;
548   p = *bsp;
549   while (p != NULL)
550     {
551       q = p->next;
552       if (p->old_val != NULL)
553         value_free (p->old_val);
554       free ((PTR)p);
555       p = q;
556     }
557   *bsp = NULL;
558 }
559
560 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
561    is part of the bpstat is copied as well.  */
562
563 bpstat
564 bpstat_copy (bs)
565      bpstat bs;
566 {
567   bpstat p = NULL;
568   bpstat tmp;
569   bpstat retval;
570
571   if (bs == NULL)
572     return bs;
573
574   for (; bs != NULL; bs = bs->next)
575     {
576       tmp = (bpstat) xmalloc (sizeof (*tmp));
577       memcpy (tmp, bs, sizeof (*tmp));
578       if (p == NULL)
579         /* This is the first thing in the chain.  */
580         retval = tmp;
581       else
582         p->next = tmp;
583       p = tmp;
584     }
585   p->next = NULL;
586   return retval;
587 }
588
589 /* Find the bpstat associated with this breakpoint */
590
591 bpstat
592 bpstat_find_breakpoint(bsp, breakpoint)
593      bpstat bsp;
594      struct breakpoint *breakpoint;
595 {
596   if (bsp == NULL) return NULL;
597
598   for (;bsp != NULL; bsp = bsp->next) {
599     if (bsp->breakpoint_at == breakpoint) return bsp;
600   }
601   return NULL;
602 }
603
604 /* Return the breakpoint number of the first breakpoint we are stopped
605    at.  *BSP upon return is a bpstat which points to the remaining
606    breakpoints stopped at (but which is not guaranteed to be good for
607    anything but further calls to bpstat_num).
608    Return 0 if passed a bpstat which does not indicate any breakpoints.  */
609
610 int
611 bpstat_num (bsp)
612      bpstat *bsp;
613 {
614   struct breakpoint *b;
615
616   if ((*bsp) == NULL)
617     return 0;                   /* No more breakpoint values */
618   else
619     {
620       b = (*bsp)->breakpoint_at;
621       *bsp = (*bsp)->next;
622       if (b == NULL)
623         return -1;              /* breakpoint that's been deleted since */
624       else
625         return b->number;       /* We have its number */
626     }
627 }
628
629 /* Modify BS so that the actions will not be performed.  */
630
631 void
632 bpstat_clear_actions (bs)
633      bpstat bs;
634 {
635   for (; bs != NULL; bs = bs->next)
636     {
637       bs->commands = NULL;
638       if (bs->old_val != NULL)
639         {
640           value_free (bs->old_val);
641           bs->old_val = NULL;
642         }
643     }
644 }
645
646 /* Stub for cleaning up our state if we error-out of a breakpoint command */
647 /* ARGSUSED */
648 static void
649 cleanup_executing_breakpoints (ignore)
650      int ignore;
651 {
652   executing_breakpoint_commands = 0;
653 }
654
655 /* Execute all the commands associated with all the breakpoints at this
656    location.  Any of these commands could cause the process to proceed
657    beyond this point, etc.  We look out for such changes by checking
658    the global "breakpoint_proceeded" after each command.  */
659
660 void
661 bpstat_do_actions (bsp)
662      bpstat *bsp;
663 {
664   bpstat bs;
665   struct cleanup *old_chain;
666
667   executing_breakpoint_commands = 1;
668   old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
669
670 top:
671   bs = *bsp;
672
673   breakpoint_proceeded = 0;
674   for (; bs != NULL; bs = bs->next)
675     {
676       while (bs->commands)
677         {
678           char *line = bs->commands->line;
679           bs->commands = bs->commands->next;
680           execute_command (line, 0);
681           /* If the inferior is proceeded by the command, bomb out now.
682              The bpstat chain has been blown away by wait_for_inferior.
683              But since execution has stopped again, there is a new bpstat
684              to look at, so start over.  */
685           if (breakpoint_proceeded)
686             goto top;
687         }
688     }
689
690   executing_breakpoint_commands = 0;
691   discard_cleanups (old_chain);
692 }
693
694 /* Print a message indicating what happened.  Returns nonzero to
695    say that only the source line should be printed after this (zero
696    return means print the frame as well as the source line).  */
697
698 int
699 bpstat_print (bs)
700      bpstat bs;
701 {
702   /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
703      which has since been deleted.  */
704   if (bs == NULL
705       || bs->breakpoint_at == NULL
706       || (bs->breakpoint_at->type != bp_breakpoint
707           && bs->breakpoint_at->type != bp_watchpoint))
708     return 0;
709   
710   /* If bpstat_stop_status says don't print, OK, we won't.  An example
711      circumstance is when we single-stepped for both a watchpoint and
712      for a "stepi" instruction.  The bpstat says that the watchpoint
713      explains the stop, but we shouldn't print because the watchpoint's
714      value didn't change -- and the real reason we are stopping here
715      rather than continuing to step (as the watchpoint would've had us do)
716      is because of the "stepi".  */
717   if (!bs->print)
718     return 0;
719
720   if (bs->breakpoint_at->type == bp_breakpoint)
721     {
722       /* I think the user probably only wants to see one breakpoint
723          number, not all of them.  */
724       printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
725       return 0;
726     }
727       
728   if (bs->old_val != NULL)
729     {
730       printf_filtered ("\nWatchpoint %d, ", bs->breakpoint_at->number);
731       print_expression (bs->breakpoint_at->exp, stdout);
732       printf_filtered ("\nOld value = ");
733       value_print (bs->old_val, stdout, 0, Val_pretty_default);
734       printf_filtered ("\nNew value = ");
735       value_print (bs->breakpoint_at->val, stdout, 0,
736                    Val_pretty_default);
737       printf_filtered ("\n");
738       value_free (bs->old_val);
739       bs->old_val = NULL;
740       return 1;
741     }
742
743   /* Maybe another breakpoint in the chain caused us to stop.
744      (Currently all watchpoints go on the bpstat whether hit or
745      not.  That probably could (should) be changed, provided care is taken
746      with respect to bpstat_explains_signal).  */
747   if (bs->next)
748     return bpstat_print (bs->next);
749
750   fprintf_filtered (stderr, "gdb internal error: in bpstat_print\n");
751   return 0;
752 }
753
754 /* Evaluate the expression EXP and return 1 if value is zero.
755    This is used inside a catch_errors to evaluate the breakpoint condition. 
756    The argument is a "struct expression *" that has been cast to char * to 
757    make it pass through catch_errors.  */
758
759 static int
760 breakpoint_cond_eval (exp)
761      char *exp;
762 {
763   return !value_true (evaluate_expression ((struct expression *)exp));
764 }
765
766 /* Allocate a new bpstat and chain it to the current one.  */
767
768 static bpstat
769 bpstat_alloc (b, cbs)
770      register struct breakpoint *b;
771      bpstat cbs;                        /* Current "bs" value */
772 {
773   bpstat bs;
774
775   bs = (bpstat) xmalloc (sizeof (*bs));
776   cbs->next = bs;
777   bs->breakpoint_at = b;
778   /* If the condition is false, etc., don't do the commands.  */
779   bs->commands = NULL;
780   bs->momentary = b->disposition == delete;
781   bs->old_val = NULL;
782   return bs;
783 }
784
785 /* Determine whether we stopped at a breakpoint, etc, or whether we
786    don't understand this stop.  Result is a chain of bpstat's such that:
787
788         if we don't understand the stop, the result is a null pointer.
789
790         if we understand why we stopped, the result is not null, and
791         the first element of the chain contains summary "stop" and
792         "print" flags for the whole chain.
793
794         Each element of the chain refers to a particular breakpoint or
795         watchpoint at which we have stopped.  (We may have stopped for
796         several reasons concurrently.)
797
798         Each element of the chain has valid next, breakpoint_at,
799         commands, FIXME??? fields.
800
801  */
802
803         
804 bpstat
805 bpstat_stop_status (pc, frame_address)
806      CORE_ADDR *pc;
807      FRAME_ADDR frame_address;
808 {
809   register struct breakpoint *b;
810   int stop = 0;
811   int print = 0;
812   CORE_ADDR bp_addr;
813 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
814   /* True if we've hit a breakpoint (as opposed to a watchpoint).  */
815   int real_breakpoint = 0;
816 #endif
817   /* Root of the chain of bpstat's */
818   struct bpstat root_bs[1];
819   /* Pointer to the last thing in the chain currently.  */
820   bpstat bs = root_bs;
821
822   /* Get the address where the breakpoint would have been.  */
823   bp_addr = *pc - DECR_PC_AFTER_BREAK;
824
825   ALL_BREAKPOINTS (b)
826     {
827       int this_bp_stop;
828       int this_bp_print;
829
830       if (b->enable == disabled)
831         continue;
832
833       if (b->type != bp_watchpoint && b->address != bp_addr)
834         continue;
835
836       /* Come here if it's a watchpoint, or if the break address matches */
837
838       bs = bpstat_alloc (b, bs);        /* Alloc a bpstat to explain stop */
839
840       this_bp_stop = 1;
841       this_bp_print = 1;
842
843       if (b->type == bp_watchpoint)
844         {
845           int within_current_scope;
846           if (b->exp_valid_block != NULL)
847             within_current_scope =
848               contained_in (get_selected_block (), b->exp_valid_block);
849           else
850             within_current_scope = 1;
851
852           if (within_current_scope)
853             {
854               /* We use value_{,free_to_}mark because it could be a
855                  *long* time before we return to the command level and
856                  call free_all_values.  */
857
858               value mark = value_mark ();
859               value new_val = evaluate_expression (b->exp);
860               if (!value_equal (b->val, new_val))
861                 {
862                   release_value (new_val);
863                   value_free_to_mark (mark);
864                   bs->old_val = b->val;
865                   b->val = new_val;
866                   /* We will stop here */
867                 }
868               else
869                 {
870                   /* Nothing changed, don't do anything.  */
871                   value_free_to_mark (mark);
872                   continue;
873                   /* We won't stop here */
874                 }
875             }
876           else
877             {
878               /* This seems like the only logical thing to do because
879                  if we temporarily ignored the watchpoint, then when
880                  we reenter the block in which it is valid it contains
881                  garbage (in the case of a function, it may have two
882                  garbage values, one before and one after the prologue).
883                  So we can't even detect the first assignment to it and
884                  watch after that (since the garbage may or may not equal
885                  the first value assigned).  */
886               b->enable = disabled;
887               printf_filtered ("\
888 Watchpoint %d disabled because the program has left the block in\n\
889 which its expression is valid.\n", b->number);
890               /* We won't stop here */
891               /* FIXME, maybe we should stop here!!! */
892               continue;
893             }
894         }
895 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
896       else
897         real_breakpoint = 1;
898 #endif
899
900       if (b->frame && b->frame != frame_address)
901         this_bp_stop = 0;
902       else
903         {
904           int value_is_zero;
905
906           if (b->cond)
907             {
908               /* Need to select the frame, with all that implies
909                  so that the conditions will have the right context.  */
910               select_frame (get_current_frame (), 0);
911               value_is_zero
912                 = catch_errors (breakpoint_cond_eval, (char *)(b->cond),
913                                 "Error in testing breakpoint condition:\n");
914                                 /* FIXME-someday, should give breakpoint # */
915               free_all_values ();
916             }
917           if (b->cond && value_is_zero)
918             {
919               this_bp_stop = 0;
920             }
921           else if (b->ignore_count > 0)
922             {
923               b->ignore_count--;
924               this_bp_stop = 0;
925             }
926           else
927             {
928               /* We will stop here */
929               if (b->disposition == disable)
930                 b->enable = disabled;
931               bs->commands = b->commands;
932               if (b->silent)
933                 this_bp_print = 0;
934               if (bs->commands && STREQ ("silent", bs->commands->line))
935                 {
936                   bs->commands = bs->commands->next;
937                   this_bp_print = 0;
938                 }
939             }
940         }
941       if (this_bp_stop)
942         stop = 1;
943       if (this_bp_print)
944         print = 1;
945     }
946
947   bs->next = NULL;              /* Terminate the chain */
948   bs = root_bs->next;           /* Re-grab the head of the chain */
949   if (bs)
950     {
951       bs->stop = stop;
952       bs->print = print;
953 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
954       if (real_breakpoint)
955         {
956           *pc = bp_addr;
957 #if defined (SHIFT_INST_REGS)
958           {
959             CORE_ADDR pc = read_register (PC_REGNUM);
960             CORE_ADDR npc = read_register (NPC_REGNUM);
961             if (pc != npc)
962               {
963                 write_register (NNPC_REGNUM, npc);
964                 write_register (NPC_REGNUM, pc);
965               }
966           }
967 #else /* No SHIFT_INST_REGS.  */
968           write_pc (bp_addr);
969 #endif /* No SHIFT_INST_REGS.  */
970         }
971 #endif /* DECR_PC_AFTER_BREAK != 0.  */
972     }
973   return bs;
974 }
975
976 /* Nonzero if we should step constantly (e.g. watchpoints on machines
977    without hardware support).  This isn't related to a specific bpstat,
978    just to things like whether watchpoints are set.  */
979
980 int 
981 bpstat_should_step ()
982 {
983   struct breakpoint *b;
984   ALL_BREAKPOINTS (b)
985     if (b->enable == enabled && b->type == bp_watchpoint)
986       return 1;
987   return 0;
988 }
989 \f
990 /* Print information on breakpoint number BNUM, or -1 if all.
991    If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
992    is nonzero, process only watchpoints.  */
993
994 static void
995 breakpoint_1 (bnum, allflag)
996      int bnum;
997      int allflag;
998 {
999   register struct breakpoint *b;
1000   register struct command_line *l;
1001   register struct symbol *sym;
1002   CORE_ADDR last_addr = (CORE_ADDR)-1;
1003   int found_a_breakpoint = 0;
1004   static char *bptypes[] = {"breakpoint", "until", "finish", "watchpoint",
1005                               "longjmp", "longjmp resume"};
1006   static char *bpdisps[] = {"del", "dis", "keep"};
1007   static char bpenables[] = "ny";
1008
1009   if (!breakpoint_chain)
1010     {
1011       printf_filtered ("No breakpoints or watchpoints.\n");
1012       return;
1013     }
1014   
1015   ALL_BREAKPOINTS (b)
1016     if (bnum == -1
1017         || bnum == b->number)
1018       {
1019 /*  We only print out user settable breakpoints unless the allflag is set. */
1020         if (!allflag
1021             && b->type != bp_breakpoint
1022             && b->type != bp_watchpoint)
1023           continue;
1024
1025         if (!found_a_breakpoint++)
1026           printf_filtered ("Num Type           Disp Enb %sWhat\n",
1027                            addressprint ? "Address    " : "");
1028
1029         printf_filtered ("%-3d %-14s %-4s %-3c ",
1030                          b->number,
1031                          bptypes[(int)b->type],
1032                          bpdisps[(int)b->disposition],
1033                          bpenables[(int)b->enable]);
1034         switch (b->type)
1035           {
1036           case bp_watchpoint:
1037             print_expression (b->exp, stdout);
1038             break;
1039           case bp_breakpoint:
1040           case bp_until:
1041           case bp_finish:
1042           case bp_longjmp:
1043           case bp_longjmp_resume:
1044             if (addressprint)
1045               printf_filtered ("%s ", local_hex_string_custom(b->address, "08"));
1046
1047             last_addr = b->address;
1048             if (b->symtab)
1049               {
1050                 sym = find_pc_function (b->address);
1051                 if (sym)
1052                   {
1053                     fputs_filtered ("in ", stdout);
1054                     fputs_filtered (SYMBOL_SOURCE_NAME (sym), stdout);
1055                     fputs_filtered (" at ", stdout);
1056                   }
1057                 fputs_filtered (b->symtab->filename, stdout);
1058                 printf_filtered (":%d", b->line_number);
1059               }
1060             else
1061               print_address_symbolic (b->address, stdout, demangle, " ");
1062           }
1063
1064         printf_filtered ("\n");
1065
1066         if (b->frame)
1067           printf_filtered ("\tstop only in stack frame at %s\n",
1068                            local_hex_string(b->frame));
1069         if (b->cond)
1070           {
1071             printf_filtered ("\tstop only if ");
1072             print_expression (b->cond, stdout);
1073             printf_filtered ("\n");
1074           }
1075         if (b->ignore_count)
1076           printf_filtered ("\tignore next %d hits\n", b->ignore_count);
1077         if ((l = b->commands))
1078           while (l)
1079             {
1080               fputs_filtered ("\t", stdout);
1081               fputs_filtered (l->line, stdout);
1082               fputs_filtered ("\n", stdout);
1083               l = l->next;
1084             }
1085       }
1086
1087   if (!found_a_breakpoint
1088       && bnum != -1)
1089     printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
1090   else
1091     /* Compare against (CORE_ADDR)-1 in case some compiler decides
1092        that a comparison of an unsigned with -1 is always false.  */
1093     if (last_addr != (CORE_ADDR)-1)
1094       set_next_address (last_addr);
1095 }
1096
1097 /* ARGSUSED */
1098 static void
1099 breakpoints_info (bnum_exp, from_tty)
1100      char *bnum_exp;
1101      int from_tty;
1102 {
1103   int bnum = -1;
1104
1105   if (bnum_exp)
1106     bnum = parse_and_eval_address (bnum_exp);
1107
1108   breakpoint_1 (bnum, 0);
1109 }
1110
1111 #if MAINTENANCE_CMDS
1112
1113 /* ARGSUSED */
1114 static void
1115 maintenance_info_breakpoints (bnum_exp, from_tty)
1116      char *bnum_exp;
1117      int from_tty;
1118 {
1119   int bnum = -1;
1120
1121   if (bnum_exp)
1122     bnum = parse_and_eval_address (bnum_exp);
1123
1124   breakpoint_1 (bnum, 1);
1125 }
1126
1127 #endif
1128
1129 /* Print a message describing any breakpoints set at PC.  */
1130
1131 static void
1132 describe_other_breakpoints (pc)
1133      register CORE_ADDR pc;
1134 {
1135   register int others = 0;
1136   register struct breakpoint *b;
1137
1138   ALL_BREAKPOINTS (b)
1139     if (b->address == pc)
1140       others++;
1141   if (others > 0)
1142     {
1143       printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
1144       ALL_BREAKPOINTS (b)
1145         if (b->address == pc)
1146           {
1147             others--;
1148             printf ("%d%s%s ",
1149                     b->number,
1150                     (b->enable == disabled) ? " (disabled)" : "",
1151                     (others > 1) ? "," : ((others == 1) ? " and" : ""));
1152           }
1153       printf ("also set at pc %s.\n", local_hex_string(pc));
1154     }
1155 }
1156 \f
1157 /* Set the default place to put a breakpoint
1158    for the `break' command with no arguments.  */
1159
1160 void
1161 set_default_breakpoint (valid, addr, symtab, line)
1162      int valid;
1163      CORE_ADDR addr;
1164      struct symtab *symtab;
1165      int line;
1166 {
1167   default_breakpoint_valid = valid;
1168   default_breakpoint_address = addr;
1169   default_breakpoint_symtab = symtab;
1170   default_breakpoint_line = line;
1171 }
1172
1173 /* Rescan breakpoints at address ADDRESS,
1174    marking the first one as "first" and any others as "duplicates".
1175    This is so that the bpt instruction is only inserted once.  */
1176
1177 static void
1178 check_duplicates (address)
1179      CORE_ADDR address;
1180 {
1181   register struct breakpoint *b;
1182   register int count = 0;
1183
1184   if (address == 0)             /* Watchpoints are uninteresting */
1185     return;
1186
1187   ALL_BREAKPOINTS (b)
1188     if (b->enable != disabled && b->address == address)
1189       {
1190         count++;
1191         b->duplicate = count > 1;
1192       }
1193 }
1194
1195 /* Low level routine to set a breakpoint.
1196    Takes as args the three things that every breakpoint must have.
1197    Returns the breakpoint object so caller can set other things.
1198    Does not set the breakpoint number!
1199    Does not print anything.
1200
1201    ==> This routine should not be called if there is a chance of later
1202    error(); otherwise it leaves a bogus breakpoint on the chain.  Validate
1203    your arguments BEFORE calling this routine!  */
1204
1205 static struct breakpoint *
1206 set_raw_breakpoint (sal)
1207      struct symtab_and_line sal;
1208 {
1209   register struct breakpoint *b, *b1;
1210
1211   b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
1212   memset (b, 0, sizeof (*b));
1213   b->address = sal.pc;
1214   b->symtab = sal.symtab;
1215   b->line_number = sal.line;
1216   b->enable = enabled;
1217   b->next = 0;
1218   b->silent = 0;
1219   b->ignore_count = 0;
1220   b->commands = NULL;
1221   b->frame = 0;
1222
1223   /* Add this breakpoint to the end of the chain
1224      so that a list of breakpoints will come out in order
1225      of increasing numbers.  */
1226
1227   b1 = breakpoint_chain;
1228   if (b1 == 0)
1229     breakpoint_chain = b;
1230   else
1231     {
1232       while (b1->next)
1233         b1 = b1->next;
1234       b1->next = b;
1235     }
1236
1237   check_duplicates (sal.pc);
1238
1239   return b;
1240 }
1241
1242 static void
1243 create_longjmp_breakpoint(func_name)
1244      char *func_name;
1245 {
1246   struct symtab_and_line sal;
1247   struct breakpoint *b;
1248   static int internal_breakpoint_number = -1;
1249
1250   if (func_name != NULL)
1251     {
1252       struct minimal_symbol *m;
1253
1254       m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
1255       if (m)
1256         sal.pc = SYMBOL_VALUE_ADDRESS (m);
1257       else
1258         return;
1259     }
1260   else
1261     sal.pc = 0;
1262
1263   sal.symtab = NULL;
1264   sal.line = 0;
1265
1266   b = set_raw_breakpoint(sal);
1267   if (!b) return;
1268
1269   b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
1270   b->disposition = donttouch;
1271   b->enable = disabled;
1272   b->silent = 1;
1273   if (func_name)
1274     b->addr_string = strsave(func_name);
1275   b->number = internal_breakpoint_number--;
1276 }
1277
1278 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1279    a longjmp().  When we hit that breakpoint, call
1280    set_longjmp_resume_breakpoint() to figure out where we are going. */
1281
1282 void
1283 enable_longjmp_breakpoint()
1284 {
1285   register struct breakpoint *b;
1286
1287   ALL_BREAKPOINTS (b)
1288     if (b->type == bp_longjmp)
1289       {
1290         b->enable = enabled;
1291         check_duplicates (b->address);
1292       }
1293 }
1294
1295 void
1296 disable_longjmp_breakpoint()
1297 {
1298   register struct breakpoint *b;
1299
1300   ALL_BREAKPOINTS (b)
1301     if (   b->type == bp_longjmp
1302         || b->type == bp_longjmp_resume)
1303       {
1304         b->enable = disabled;
1305         check_duplicates (b->address);
1306       }
1307 }
1308
1309 /* Call this after hitting the longjmp() breakpoint.  Use this to set a new
1310    breakpoint at the target of the jmp_buf.
1311
1312    FIXME - This ought to be done by setting a temporary breakpoint that gets
1313    deleted automatically...
1314 */
1315
1316 void
1317 set_longjmp_resume_breakpoint(pc, frame)
1318      CORE_ADDR pc;
1319      FRAME frame;
1320 {
1321   register struct breakpoint *b;
1322
1323   ALL_BREAKPOINTS (b)
1324     if (b->type == bp_longjmp_resume)
1325       {
1326         b->address = pc;
1327         b->enable = enabled;
1328         if (frame != NULL)
1329           b->frame = FRAME_FP(frame);
1330         else
1331           b->frame = 0;
1332         check_duplicates (b->address);
1333         return;
1334       }
1335 }
1336
1337 /* Set a breakpoint that will evaporate an end of command
1338    at address specified by SAL.
1339    Restrict it to frame FRAME if FRAME is nonzero.  */
1340
1341 struct breakpoint *
1342 set_momentary_breakpoint (sal, frame, type)
1343      struct symtab_and_line sal;
1344      FRAME frame;
1345      enum bptype type;
1346 {
1347   register struct breakpoint *b;
1348   b = set_raw_breakpoint (sal);
1349   b->type = type;
1350   b->enable = enabled;
1351   b->disposition = donttouch;
1352   b->frame = (frame ? FRAME_FP (frame) : 0);
1353   return b;
1354 }
1355
1356 #if 0
1357 void
1358 clear_momentary_breakpoints ()
1359 {
1360   register struct breakpoint *b;
1361   ALL_BREAKPOINTS (b)
1362     if (b->disposition == delete)
1363       {
1364         delete_breakpoint (b);
1365         break;
1366       }
1367 }
1368 #endif
1369 \f
1370 /* Tell the user we have just set a breakpoint B.  */
1371 static void
1372 mention (b)
1373      struct breakpoint *b;
1374 {
1375   switch (b->type)
1376     {
1377     case bp_watchpoint:
1378       printf_filtered ("Watchpoint %d: ", b->number);
1379       print_expression (b->exp, stdout);
1380       break;
1381     case bp_breakpoint:
1382       printf_filtered ("Breakpoint %d at %s", b->number,
1383                        local_hex_string(b->address));
1384       if (b->symtab)
1385         printf_filtered (": file %s, line %d.",
1386                          b->symtab->filename, b->line_number);
1387       break;
1388     case bp_until:
1389     case bp_finish:
1390     case bp_longjmp:
1391     case bp_longjmp_resume:
1392       break;
1393     }
1394   printf_filtered ("\n");
1395 }
1396
1397 #if 0
1398 /* Nobody calls this currently. */
1399 /* Set a breakpoint from a symtab and line.
1400    If TEMPFLAG is nonzero, it is a temporary breakpoint.
1401    ADDR_STRING is a malloc'd string holding the name of where we are
1402    setting the breakpoint.  This is used later to re-set it after the
1403    program is relinked and symbols are reloaded.
1404    Print the same confirmation messages that the breakpoint command prints.  */
1405
1406 void
1407 set_breakpoint (s, line, tempflag, addr_string)
1408      struct symtab *s;
1409      int line;
1410      int tempflag;
1411      char *addr_string;
1412 {
1413   register struct breakpoint *b;
1414   struct symtab_and_line sal;
1415   
1416   sal.symtab = s;
1417   sal.line = line;
1418   sal.pc = 0;
1419   resolve_sal_pc (&sal);                        /* Might error out */
1420   describe_other_breakpoints (sal.pc);
1421
1422   b = set_raw_breakpoint (sal);
1423   set_breakpoint_count (breakpoint_count + 1);
1424   b->number = breakpoint_count;
1425   b->type = bp_breakpoint;
1426   b->cond = 0;
1427   b->addr_string = addr_string;
1428   b->enable = enabled;
1429   b->disposition = tempflag ? delete : donttouch;
1430
1431   mention (b);
1432 }
1433 #endif /* 0 */
1434 \f
1435 /* Set a breakpoint according to ARG (function, linenum or *address)
1436    and make it temporary if TEMPFLAG is nonzero. */
1437
1438 static void
1439 break_command_1 (arg, tempflag, from_tty)
1440      char *arg;
1441      int tempflag, from_tty;
1442 {
1443   struct symtabs_and_lines sals;
1444   struct symtab_and_line sal;
1445   register struct expression *cond = 0;
1446   register struct breakpoint *b;
1447
1448   /* Pointers in arg to the start, and one past the end, of the condition.  */
1449   char *cond_start = NULL;
1450   char *cond_end;
1451   /* Pointers in arg to the start, and one past the end,
1452      of the address part.  */
1453   char *addr_start = NULL;
1454   char *addr_end;
1455   
1456   int i;
1457
1458   sals.sals = NULL;
1459   sals.nelts = 0;
1460
1461   sal.line = sal.pc = sal.end = 0;
1462   sal.symtab = 0;
1463
1464   /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1465
1466   if (!arg || (arg[0] == 'i' && arg[1] == 'f' 
1467                && (arg[2] == ' ' || arg[2] == '\t')))
1468     {
1469       if (default_breakpoint_valid)
1470         {
1471           sals.sals = (struct symtab_and_line *) 
1472             xmalloc (sizeof (struct symtab_and_line));
1473           sal.pc = default_breakpoint_address;
1474           sal.line = default_breakpoint_line;
1475           sal.symtab = default_breakpoint_symtab;
1476           sals.sals[0] = sal;
1477           sals.nelts = 1;
1478         }
1479       else
1480         error ("No default breakpoint address now.");
1481     }
1482   else
1483     {
1484       addr_start = arg;
1485
1486       /* Force almost all breakpoints to be in terms of the
1487          current_source_symtab (which is decode_line_1's default).  This
1488          should produce the results we want almost all of the time while
1489          leaving default_breakpoint_* alone.  */
1490       if (default_breakpoint_valid
1491           && (!current_source_symtab
1492               || (arg && (*arg == '+' || *arg == '-'))))
1493         sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1494                               default_breakpoint_line);
1495       else
1496         sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1497
1498       addr_end = arg;
1499     }
1500   
1501   if (! sals.nelts) 
1502     return;
1503
1504   /* Resolve all line numbers to PC's, and verify that conditions
1505      can be parsed, before setting any breakpoints.  */
1506   for (i = 0; i < sals.nelts; i++)
1507     {
1508       resolve_sal_pc (&sals.sals[i]);
1509       
1510       while (arg && *arg)
1511         {
1512           if (arg[0] == 'i' && arg[1] == 'f'
1513               && (arg[2] == ' ' || arg[2] == '\t'))
1514             {
1515               arg += 2;
1516               cond_start = arg;
1517               cond = parse_exp_1 (&arg, block_for_pc (sals.sals[i].pc), 0);
1518               cond_end = arg;
1519             }
1520           else
1521             error ("Junk at end of arguments.");
1522         }
1523     }
1524
1525   /* Now set all the breakpoints.  */
1526   for (i = 0; i < sals.nelts; i++)
1527     {
1528       sal = sals.sals[i];
1529
1530       if (from_tty)
1531         describe_other_breakpoints (sal.pc);
1532
1533       b = set_raw_breakpoint (sal);
1534       set_breakpoint_count (breakpoint_count + 1);
1535       b->number = breakpoint_count;
1536       b->type = bp_breakpoint;
1537       b->cond = cond;
1538       
1539       if (addr_start)
1540         b->addr_string = savestring (addr_start, addr_end - addr_start);
1541       if (cond_start)
1542         b->cond_string = savestring (cond_start, cond_end - cond_start);
1543                                      
1544       b->enable = enabled;
1545       b->disposition = tempflag ? delete : donttouch;
1546
1547       mention (b);
1548     }
1549
1550   if (sals.nelts > 1)
1551     {
1552       printf ("Multiple breakpoints were set.\n");
1553       printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1554     }
1555   free ((PTR)sals.sals);
1556 }
1557
1558 /* Helper function for break_command_1 and disassemble_command.  */
1559
1560 void
1561 resolve_sal_pc (sal)
1562      struct symtab_and_line *sal;
1563 {
1564   CORE_ADDR pc;
1565
1566   if (sal->pc == 0 && sal->symtab != 0)
1567     {
1568       pc = find_line_pc (sal->symtab, sal->line);
1569       if (pc == 0)
1570         error ("No line %d in file \"%s\".",
1571                sal->line, sal->symtab->filename);
1572       sal->pc = pc;
1573     }
1574 }
1575
1576 void
1577 break_command (arg, from_tty)
1578      char *arg;
1579      int from_tty;
1580 {
1581   break_command_1 (arg, 0, from_tty);
1582 }
1583
1584 static void
1585 tbreak_command (arg, from_tty)
1586      char *arg;
1587      int from_tty;
1588 {
1589   break_command_1 (arg, 1, from_tty);
1590 }
1591
1592 /* ARGSUSED */
1593 static void
1594 watch_command (arg, from_tty)
1595      char *arg;
1596      int from_tty;
1597 {
1598   struct breakpoint *b;
1599   struct symtab_and_line sal;
1600   struct expression *exp;
1601   struct block *exp_valid_block;
1602   struct value *val;
1603
1604   sal.pc = 0;
1605   sal.symtab = NULL;
1606   sal.line = 0;
1607   
1608   /* Parse arguments.  */
1609   innermost_block = NULL;
1610   exp = parse_expression (arg);
1611   exp_valid_block = innermost_block;
1612   val = evaluate_expression (exp);
1613   release_value (val);
1614   if (VALUE_LAZY (val))
1615     value_fetch_lazy (val);
1616
1617   /* Now set up the breakpoint.  */
1618   b = set_raw_breakpoint (sal);
1619   set_breakpoint_count (breakpoint_count + 1);
1620   b->number = breakpoint_count;
1621   b->type = bp_watchpoint;
1622   b->disposition = donttouch;
1623   b->exp = exp;
1624   b->exp_valid_block = exp_valid_block;
1625   b->val = val;
1626   b->cond = 0;
1627   b->cond_string = NULL;
1628   mention (b);
1629 }
1630 \f
1631 /*
1632  * Helper routine for the until_command routine in infcmd.c.  Here
1633  * because it uses the mechanisms of breakpoints.
1634  */
1635 /* ARGSUSED */
1636 void
1637 until_break_command (arg, from_tty)
1638      char *arg;
1639      int from_tty;
1640 {
1641   struct symtabs_and_lines sals;
1642   struct symtab_and_line sal;
1643   FRAME prev_frame = get_prev_frame (selected_frame);
1644   struct breakpoint *breakpoint;
1645   struct cleanup *old_chain;
1646
1647   clear_proceed_status ();
1648
1649   /* Set a breakpoint where the user wants it and at return from
1650      this function */
1651   
1652   if (default_breakpoint_valid)
1653     sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1654                           default_breakpoint_line);
1655   else
1656     sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1657   
1658   if (sals.nelts != 1)
1659     error ("Couldn't get information on specified line.");
1660   
1661   sal = sals.sals[0];
1662   free ((PTR)sals.sals);                /* malloc'd, so freed */
1663   
1664   if (*arg)
1665     error ("Junk at end of arguments.");
1666   
1667   resolve_sal_pc (&sal);
1668   
1669   breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
1670   
1671   old_chain = make_cleanup(delete_breakpoint, breakpoint);
1672
1673   /* Keep within the current frame */
1674   
1675   if (prev_frame)
1676     {
1677       struct frame_info *fi;
1678       
1679       fi = get_frame_info (prev_frame);
1680       sal = find_pc_line (fi->pc, 0);
1681       sal.pc = fi->pc;
1682       breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
1683       make_cleanup(delete_breakpoint, breakpoint);
1684     }
1685   
1686   proceed (-1, -1, 0);
1687   do_cleanups(old_chain);
1688 }
1689 \f
1690 #if 0
1691 /* These aren't used; I don't konw what they were for.  */
1692 /* Set a breakpoint at the catch clause for NAME.  */
1693 static int
1694 catch_breakpoint (name)
1695      char *name;
1696 {
1697 }
1698
1699 static int
1700 disable_catch_breakpoint ()
1701 {
1702 }
1703
1704 static int
1705 delete_catch_breakpoint ()
1706 {
1707 }
1708
1709 static int
1710 enable_catch_breakpoint ()
1711 {
1712 }
1713 #endif /* 0 */
1714
1715 struct sal_chain
1716 {
1717   struct sal_chain *next;
1718   struct symtab_and_line sal;
1719 };
1720
1721 #if 0
1722 /* This isn't used; I don't know what it was for.  */
1723 /* For each catch clause identified in ARGS, run FUNCTION
1724    with that clause as an argument.  */
1725 static struct symtabs_and_lines
1726 map_catch_names (args, function)
1727      char *args;
1728      int (*function)();
1729 {
1730   register char *p = args;
1731   register char *p1;
1732   struct symtabs_and_lines sals;
1733 #if 0
1734   struct sal_chain *sal_chain = 0;
1735 #endif
1736
1737   if (p == 0)
1738     error_no_arg ("one or more catch names");
1739
1740   sals.nelts = 0;
1741   sals.sals = NULL;
1742
1743   while (*p)
1744     {
1745       p1 = p;
1746       /* Don't swallow conditional part.  */
1747       if (p1[0] == 'i' && p1[1] == 'f'
1748           && (p1[2] == ' ' || p1[2] == '\t'))
1749         break;
1750
1751       if (isalpha (*p1))
1752         {
1753           p1++;
1754           while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
1755             p1++;
1756         }
1757
1758       if (*p1 && *p1 != ' ' && *p1 != '\t')
1759         error ("Arguments must be catch names.");
1760
1761       *p1 = 0;
1762 #if 0
1763       if (function (p))
1764         {
1765           struct sal_chain *next
1766             = (struct sal_chain *)alloca (sizeof (struct sal_chain));
1767           next->next = sal_chain;
1768           next->sal = get_catch_sal (p);
1769           sal_chain = next;
1770           goto win;
1771         }
1772 #endif
1773       printf ("No catch clause for exception %s.\n", p);
1774 #if 0
1775     win:
1776 #endif
1777       p = p1;
1778       while (*p == ' ' || *p == '\t') p++;
1779     }
1780 }
1781 #endif /* 0 */
1782
1783 /* This shares a lot of code with `print_frame_label_vars' from stack.c.  */
1784
1785 static struct symtabs_and_lines
1786 get_catch_sals (this_level_only)
1787      int this_level_only;
1788 {
1789   register struct blockvector *bl;
1790   register struct block *block;
1791   int index, have_default = 0;
1792   struct frame_info *fi;
1793   CORE_ADDR pc;
1794   struct symtabs_and_lines sals;
1795   struct sal_chain *sal_chain = 0;
1796   char *blocks_searched;
1797
1798   /* Not sure whether an error message is always the correct response,
1799      but it's better than a core dump.  */
1800   if (selected_frame == NULL)
1801     error ("No selected frame.");
1802   block = get_frame_block (selected_frame);
1803   fi = get_frame_info (selected_frame);
1804   pc = fi->pc;
1805
1806   sals.nelts = 0;
1807   sals.sals = NULL;
1808
1809   if (block == 0)
1810     error ("No symbol table info available.\n");
1811
1812   bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1813   blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1814   memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1815
1816   while (block != 0)
1817     {
1818       CORE_ADDR end = BLOCK_END (block) - 4;
1819       int last_index;
1820
1821       if (bl != blockvector_for_pc (end, &index))
1822         error ("blockvector blotch");
1823       if (BLOCKVECTOR_BLOCK (bl, index) != block)
1824         error ("blockvector botch");
1825       last_index = BLOCKVECTOR_NBLOCKS (bl);
1826       index += 1;
1827
1828       /* Don't print out blocks that have gone by.  */
1829       while (index < last_index
1830              && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1831         index++;
1832
1833       while (index < last_index
1834              && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1835         {
1836           if (blocks_searched[index] == 0)
1837             {
1838               struct block *b = BLOCKVECTOR_BLOCK (bl, index);
1839               int nsyms;
1840               register int i;
1841               register struct symbol *sym;
1842
1843               nsyms = BLOCK_NSYMS (b);
1844
1845               for (i = 0; i < nsyms; i++)
1846                 {
1847                   sym = BLOCK_SYM (b, i);
1848                   if (STREQ (SYMBOL_NAME (sym), "default"))
1849                     {
1850                       if (have_default)
1851                         continue;
1852                       have_default = 1;
1853                     }
1854                   if (SYMBOL_CLASS (sym) == LOC_LABEL)
1855                     {
1856                       struct sal_chain *next = (struct sal_chain *)
1857                         alloca (sizeof (struct sal_chain));
1858                       next->next = sal_chain;
1859                       next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1860                       sal_chain = next;
1861                     }
1862                 }
1863               blocks_searched[index] = 1;
1864             }
1865           index++;
1866         }
1867       if (have_default)
1868         break;
1869       if (sal_chain && this_level_only)
1870         break;
1871
1872       /* After handling the function's top-level block, stop.
1873          Don't continue to its superblock, the block of
1874          per-file symbols.  */
1875       if (BLOCK_FUNCTION (block))
1876         break;
1877       block = BLOCK_SUPERBLOCK (block);
1878     }
1879
1880   if (sal_chain)
1881     {
1882       struct sal_chain *tmp_chain;
1883
1884       /* Count the number of entries.  */
1885       for (index = 0, tmp_chain = sal_chain; tmp_chain;
1886            tmp_chain = tmp_chain->next)
1887         index++;
1888
1889       sals.nelts = index;
1890       sals.sals = (struct symtab_and_line *)
1891         xmalloc (index * sizeof (struct symtab_and_line));
1892       for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
1893         sals.sals[index] = sal_chain->sal;
1894     }
1895
1896   return sals;
1897 }
1898
1899 /* Commands to deal with catching exceptions.  */
1900
1901 static void
1902 catch_command_1 (arg, tempflag, from_tty)
1903      char *arg;
1904      int tempflag;
1905      int from_tty;
1906 {
1907   /* First, translate ARG into something we can deal with in terms
1908      of breakpoints.  */
1909
1910   struct symtabs_and_lines sals;
1911   struct symtab_and_line sal;
1912   register struct expression *cond = 0;
1913   register struct breakpoint *b;
1914   char *save_arg;
1915   int i;
1916
1917   sal.line = sal.pc = sal.end = 0;
1918   sal.symtab = 0;
1919
1920   /* If no arg given, or if first arg is 'if ', all active catch clauses
1921      are breakpointed. */
1922
1923   if (!arg || (arg[0] == 'i' && arg[1] == 'f' 
1924                && (arg[2] == ' ' || arg[2] == '\t')))
1925     {
1926       /* Grab all active catch clauses.  */
1927       sals = get_catch_sals (0);
1928     }
1929   else
1930     {
1931       /* Grab selected catch clauses.  */
1932       error ("catch NAME not implemeneted");
1933 #if 0
1934       /* This isn't used; I don't know what it was for.  */
1935       sals = map_catch_names (arg, catch_breakpoint);
1936 #endif
1937     }
1938
1939   if (! sals.nelts) 
1940     return;
1941
1942   save_arg = arg;
1943   for (i = 0; i < sals.nelts; i++)
1944     {
1945       resolve_sal_pc (&sals.sals[i]);
1946       
1947       while (arg && *arg)
1948         {
1949           if (arg[0] == 'i' && arg[1] == 'f'
1950               && (arg[2] == ' ' || arg[2] == '\t'))
1951             cond = parse_exp_1 ((arg += 2, &arg), 
1952                                 block_for_pc (sals.sals[i].pc), 0);
1953           else
1954             error ("Junk at end of arguments.");
1955         }
1956       arg = save_arg;
1957     }
1958
1959   for (i = 0; i < sals.nelts; i++)
1960     {
1961       sal = sals.sals[i];
1962
1963       if (from_tty)
1964         describe_other_breakpoints (sal.pc);
1965
1966       b = set_raw_breakpoint (sal);
1967       set_breakpoint_count (breakpoint_count + 1);
1968       b->number = breakpoint_count;
1969       b->type = bp_breakpoint;
1970       b->cond = cond;
1971       b->enable = enabled;
1972       b->disposition = tempflag ? delete : donttouch;
1973
1974       printf ("Breakpoint %d at %s", b->number, local_hex_string(b->address));
1975       if (b->symtab)
1976         printf (": file %s, line %d.", b->symtab->filename, b->line_number);
1977       printf ("\n");
1978     }
1979
1980   if (sals.nelts > 1)
1981     {
1982       printf ("Multiple breakpoints were set.\n");
1983       printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1984     }
1985   free ((PTR)sals.sals);
1986 }
1987
1988 #if 0
1989 /* These aren't used; I don't know what they were for.  */
1990 /* Disable breakpoints on all catch clauses described in ARGS.  */
1991 static void
1992 disable_catch (args)
1993      char *args;
1994 {
1995   /* Map the disable command to catch clauses described in ARGS.  */
1996 }
1997
1998 /* Enable breakpoints on all catch clauses described in ARGS.  */
1999 static void
2000 enable_catch (args)
2001      char *args;
2002 {
2003   /* Map the disable command to catch clauses described in ARGS.  */
2004 }
2005
2006 /* Delete breakpoints on all catch clauses in the active scope.  */
2007 static void
2008 delete_catch (args)
2009      char *args;
2010 {
2011   /* Map the delete command to catch clauses described in ARGS.  */
2012 }
2013 #endif /* 0 */
2014
2015 static void
2016 catch_command (arg, from_tty)
2017      char *arg;
2018      int from_tty;
2019 {
2020   catch_command_1 (arg, 0, from_tty);
2021 }
2022 \f
2023 static void
2024 clear_command (arg, from_tty)
2025      char *arg;
2026      int from_tty;
2027 {
2028   register struct breakpoint *b, *b1;
2029   struct symtabs_and_lines sals;
2030   struct symtab_and_line sal;
2031   register struct breakpoint *found;
2032   int i;
2033
2034   if (arg)
2035     {
2036       sals = decode_line_spec (arg, 1);
2037     }
2038   else
2039     {
2040       sals.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
2041       sal.line = default_breakpoint_line;
2042       sal.symtab = default_breakpoint_symtab;
2043       sal.pc = 0;
2044       if (sal.symtab == 0)
2045         error ("No source file specified.");
2046
2047       sals.sals[0] = sal;
2048       sals.nelts = 1;
2049     }
2050
2051   for (i = 0; i < sals.nelts; i++)
2052     {
2053       /* If exact pc given, clear bpts at that pc.
2054          But if sal.pc is zero, clear all bpts on specified line.  */
2055       sal = sals.sals[i];
2056       found = (struct breakpoint *) 0;
2057       while (breakpoint_chain
2058              && (sal.pc ? breakpoint_chain->address == sal.pc
2059                  : (breakpoint_chain->symtab == sal.symtab
2060                     && breakpoint_chain->line_number == sal.line)))
2061         {
2062           b1 = breakpoint_chain;
2063           breakpoint_chain = b1->next;
2064           b1->next = found;
2065           found = b1;
2066         }
2067
2068       ALL_BREAKPOINTS (b)
2069         while (b->next
2070                && b->next->type != bp_watchpoint
2071                && (sal.pc ? b->next->address == sal.pc
2072                    : (b->next->symtab == sal.symtab
2073                       && b->next->line_number == sal.line)))
2074           {
2075             b1 = b->next;
2076             b->next = b1->next;
2077             b1->next = found;
2078             found = b1;
2079           }
2080
2081       if (found == 0)
2082         {
2083           if (arg)
2084             error ("No breakpoint at %s.", arg);
2085           else
2086             error ("No breakpoint at this line.");
2087         }
2088
2089       if (found->next) from_tty = 1; /* Always report if deleted more than one */
2090       if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
2091       while (found)
2092         {
2093           if (from_tty) printf ("%d ", found->number);
2094           b1 = found->next;
2095           delete_breakpoint (found);
2096           found = b1;
2097         }
2098       if (from_tty) putchar ('\n');
2099     }
2100   free ((PTR)sals.sals);
2101 }
2102 \f
2103 /* Delete breakpoint in BS if they are `delete' breakpoints.
2104    This is called after any breakpoint is hit, or after errors.  */
2105
2106 void
2107 breakpoint_auto_delete (bs)
2108      bpstat bs;
2109 {
2110   for (; bs; bs = bs->next)
2111     if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete)
2112       delete_breakpoint (bs->breakpoint_at);
2113 }
2114
2115 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2116
2117 void
2118 delete_breakpoint (bpt)
2119      struct breakpoint *bpt;
2120 {
2121   register struct breakpoint *b;
2122   register bpstat bs;
2123
2124   if (bpt->inserted)
2125       target_remove_breakpoint(bpt->address, bpt->shadow_contents);
2126
2127   if (breakpoint_chain == bpt)
2128     breakpoint_chain = bpt->next;
2129
2130   ALL_BREAKPOINTS (b)
2131     if (b->next == bpt)
2132       {
2133         b->next = bpt->next;
2134         break;
2135       }
2136
2137   check_duplicates (bpt->address);
2138
2139   free_command_lines (&bpt->commands);
2140   if (bpt->cond)
2141     free ((PTR)bpt->cond);
2142   if (bpt->cond_string != NULL)
2143     free ((PTR)bpt->cond_string);
2144   if (bpt->addr_string != NULL)
2145     free ((PTR)bpt->addr_string);
2146
2147   if (xgdb_verbose && bpt->type == bp_breakpoint)
2148     printf ("breakpoint #%d deleted\n", bpt->number);
2149
2150   /* Be sure no bpstat's are pointing at it after it's been freed.  */
2151   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat for now. */
2152   for (bs = stop_bpstat; bs; bs = bs->next)
2153     if (bs->breakpoint_at == bpt)
2154       bs->breakpoint_at = NULL;
2155   free ((PTR)bpt);
2156 }
2157
2158 static void
2159 delete_command (arg, from_tty)
2160      char *arg;
2161      int from_tty;
2162 {
2163
2164   if (arg == 0)
2165     {
2166       /* Ask user only if there are some breakpoints to delete.  */
2167       if (!from_tty
2168           || (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
2169         {
2170           /* No arg; clear all breakpoints.  */
2171           while (breakpoint_chain)
2172             delete_breakpoint (breakpoint_chain);
2173         }
2174     }
2175   else
2176     map_breakpoint_numbers (arg, delete_breakpoint);
2177 }
2178
2179 /* Reset a breakpoint given it's struct breakpoint * BINT.
2180    The value we return ends up being the return value from catch_errors.
2181    Unused in this case.  */
2182
2183 static int
2184 breakpoint_re_set_one (bint)
2185      char *bint;
2186 {
2187   struct breakpoint *b = (struct breakpoint *)bint;  /* get past catch_errs */
2188   int i;
2189   struct symtabs_and_lines sals;
2190   char *s;
2191   enum enable save_enable;
2192
2193   switch (b->type)
2194     {
2195     case bp_breakpoint:
2196       if (b->addr_string == NULL)
2197         {
2198           /* Anything without a string can't be re-set. */
2199           delete_breakpoint (b);
2200           return 0;
2201         }
2202       /* In case we have a problem, disable this breakpoint.  We'll restore
2203          its status if we succeed.  */
2204       save_enable = b->enable;
2205       b->enable = disabled;
2206
2207       s = b->addr_string;
2208       sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0);
2209       for (i = 0; i < sals.nelts; i++)
2210         {
2211           resolve_sal_pc (&sals.sals[i]);
2212           if (b->symtab != sals.sals[i].symtab
2213               || b->line_number != sals.sals[i].line
2214               || b->address != sals.sals[i].pc)
2215             {
2216               b->symtab = sals.sals[i].symtab;
2217               b->line_number = sals.sals[i].line;
2218               b->address = sals.sals[i].pc;
2219
2220               if (b->cond_string != NULL)
2221                 {
2222                   s = b->cond_string;
2223                   b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
2224                 }
2225           
2226               check_duplicates (b->address);
2227
2228               mention (b);
2229             }
2230           b->enable = save_enable;      /* Restore it, this worked. */
2231         }
2232       free ((PTR)sals.sals);
2233       break;
2234
2235     case bp_watchpoint:
2236       if (b->cond_string != NULL)
2237         {
2238           s = b->cond_string;
2239           b->cond = parse_exp_1 (&s, (struct block *)0, 0);
2240         }
2241       break;
2242
2243     default:
2244       printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
2245       /* fall through */
2246     case bp_until:
2247     case bp_finish:
2248     case bp_longjmp:
2249     case bp_longjmp_resume:
2250       delete_breakpoint (b);
2251       break;
2252     }
2253
2254   return 0;
2255 }
2256
2257 /* Re-set all breakpoints after symbols have been re-loaded.  */
2258 void
2259 breakpoint_re_set ()
2260 {
2261   struct breakpoint *b, *temp;
2262   static char message1[] = "Error in re-setting breakpoint %d:\n";
2263   char message[sizeof (message1) + 30 /* slop */];
2264   
2265   /* If we have no current source symtab, and we have any breakpoints,
2266      go through the work of making a source context.  */
2267   if (current_source_symtab == NULL && breakpoint_chain != 0)
2268     {
2269       select_source_symtab (NULL);
2270     }
2271
2272   ALL_BREAKPOINTS_SAFE (b, temp)
2273     {
2274       sprintf (message, message1, b->number);   /* Format possible error msg */
2275       catch_errors (breakpoint_re_set_one, (char *) b, message);
2276     }
2277
2278   create_longjmp_breakpoint("longjmp");
2279   create_longjmp_breakpoint("_longjmp");
2280   create_longjmp_breakpoint("siglongjmp");
2281   create_longjmp_breakpoint(NULL);
2282
2283 #if 0
2284   /* Took this out (temporaliy at least), since it produces an extra 
2285      blank line at startup. This messes up the gdbtests. -PB */
2286   /* Blank line to finish off all those mention() messages we just printed.  */
2287   printf_filtered ("\n");
2288 #endif
2289 }
2290 \f
2291 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2292    If from_tty is nonzero, it prints a message to that effect,
2293    which ends with a period (no newline).  */
2294
2295 void
2296 set_ignore_count (bptnum, count, from_tty)
2297      int bptnum, count, from_tty;
2298 {
2299   register struct breakpoint *b;
2300
2301   if (count < 0)
2302     count = 0;
2303
2304   ALL_BREAKPOINTS (b)
2305     if (b->number == bptnum)
2306       {
2307         b->ignore_count = count;
2308         if (!from_tty)
2309           return;
2310         else if (count == 0)
2311           printf_filtered ("Will stop next time breakpoint %d is reached.",
2312                            bptnum);
2313         else if (count == 1)
2314           printf_filtered ("Will ignore next crossing of breakpoint %d.",
2315                            bptnum);
2316         else
2317           printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2318                   count, bptnum);
2319         return;
2320       }
2321
2322   error ("No breakpoint number %d.", bptnum);
2323 }
2324
2325 /* Clear the ignore counts of all breakpoints.  */
2326 void
2327 breakpoint_clear_ignore_counts ()
2328 {
2329   struct breakpoint *b;
2330
2331   ALL_BREAKPOINTS (b)
2332     b->ignore_count = 0;
2333 }
2334
2335 /* Command to set ignore-count of breakpoint N to COUNT.  */
2336
2337 static void
2338 ignore_command (args, from_tty)
2339      char *args;
2340      int from_tty;
2341 {
2342   char *p = args;
2343   register int num;
2344
2345   if (p == 0)
2346     error_no_arg ("a breakpoint number");
2347   
2348   num = get_number (&p);
2349
2350   if (*p == 0)
2351     error ("Second argument (specified ignore-count) is missing.");
2352
2353   set_ignore_count (num,
2354                     longest_to_int (value_as_long (parse_and_eval (p))),
2355                     from_tty);
2356   printf_filtered ("\n");
2357 }
2358 \f
2359 /* Call FUNCTION on each of the breakpoints
2360    whose numbers are given in ARGS.  */
2361
2362 static void
2363 map_breakpoint_numbers (args, function)
2364      char *args;
2365      void (*function) PARAMS ((struct breakpoint *));
2366 {
2367   register char *p = args;
2368   char *p1;
2369   register int num;
2370   register struct breakpoint *b;
2371
2372   if (p == 0)
2373     error_no_arg ("one or more breakpoint numbers");
2374
2375   while (*p)
2376     {
2377       p1 = p;
2378       
2379       num = get_number (&p1);
2380
2381       ALL_BREAKPOINTS (b)
2382         if (b->number == num)
2383           {
2384             function (b);
2385             goto win;
2386           }
2387       printf ("No breakpoint number %d.\n", num);
2388     win:
2389       p = p1;
2390     }
2391 }
2392
2393 static void
2394 enable_breakpoint (bpt)
2395      struct breakpoint *bpt;
2396 {
2397   bpt->enable = enabled;
2398
2399   if (xgdb_verbose && bpt->type == bp_breakpoint)
2400     printf ("breakpoint #%d enabled\n", bpt->number);
2401
2402   check_duplicates (bpt->address);
2403   if (bpt->type == bp_watchpoint)
2404     {
2405       if (bpt->exp_valid_block != NULL
2406        && !contained_in (get_selected_block (), bpt->exp_valid_block))
2407         {
2408           printf_filtered ("\
2409 Cannot enable watchpoint %d because the block in which its expression\n\
2410 is valid is not currently in scope.\n", bpt->number);
2411           return;
2412         }
2413
2414       value_free (bpt->val);
2415
2416       bpt->val = evaluate_expression (bpt->exp);
2417       release_value (bpt->val);
2418       if (VALUE_LAZY (bpt->val))
2419         value_fetch_lazy (bpt->val);
2420     }
2421 }
2422
2423 /* ARGSUSED */
2424 static void
2425 enable_command (args, from_tty)
2426      char *args;
2427      int from_tty;
2428 {
2429   struct breakpoint *bpt;
2430   if (args == 0)
2431     ALL_BREAKPOINTS (bpt)
2432       switch (bpt->type)
2433         {
2434         case bp_breakpoint:
2435         case bp_watchpoint:
2436           enable_breakpoint (bpt);
2437         default:
2438           continue;
2439         }
2440   else
2441     map_breakpoint_numbers (args, enable_breakpoint);
2442 }
2443
2444 static void
2445 disable_breakpoint (bpt)
2446      struct breakpoint *bpt;
2447 {
2448   bpt->enable = disabled;
2449
2450   if (xgdb_verbose && bpt->type == bp_breakpoint)
2451     printf_filtered ("breakpoint #%d disabled\n", bpt->number);
2452
2453   check_duplicates (bpt->address);
2454 }
2455
2456 /* ARGSUSED */
2457 static void
2458 disable_command (args, from_tty)
2459      char *args;
2460      int from_tty;
2461 {
2462   register struct breakpoint *bpt;
2463   if (args == 0)
2464     ALL_BREAKPOINTS (bpt)
2465       switch (bpt->type)
2466         {
2467         case bp_breakpoint:
2468         case bp_watchpoint:
2469           disable_breakpoint (bpt);
2470         default:
2471           continue;
2472         }
2473   else
2474     map_breakpoint_numbers (args, disable_breakpoint);
2475 }
2476
2477 static void
2478 enable_once_breakpoint (bpt)
2479      struct breakpoint *bpt;
2480 {
2481   bpt->enable = enabled;
2482   bpt->disposition = disable;
2483
2484   check_duplicates (bpt->address);
2485 }
2486
2487 /* ARGSUSED */
2488 static void
2489 enable_once_command (args, from_tty)
2490      char *args;
2491      int from_tty;
2492 {
2493   map_breakpoint_numbers (args, enable_once_breakpoint);
2494 }
2495
2496 static void
2497 enable_delete_breakpoint (bpt)
2498      struct breakpoint *bpt;
2499 {
2500   bpt->enable = enabled;
2501   bpt->disposition = delete;
2502
2503   check_duplicates (bpt->address);
2504 }
2505
2506 /* ARGSUSED */
2507 static void
2508 enable_delete_command (args, from_tty)
2509      char *args;
2510      int from_tty;
2511 {
2512   map_breakpoint_numbers (args, enable_delete_breakpoint);
2513 }
2514 \f
2515 /*
2516  * Use default_breakpoint_'s, or nothing if they aren't valid.
2517  */
2518 struct symtabs_and_lines
2519 decode_line_spec_1 (string, funfirstline)
2520      char *string;
2521      int funfirstline;
2522 {
2523   struct symtabs_and_lines sals;
2524   if (string == 0)
2525     error ("Empty line specification.");
2526   if (default_breakpoint_valid)
2527     sals = decode_line_1 (&string, funfirstline,
2528                           default_breakpoint_symtab, default_breakpoint_line);
2529   else
2530     sals = decode_line_1 (&string, funfirstline, (struct symtab *)NULL, 0);
2531   if (*string)
2532     error ("Junk at end of line specification: %s", string);
2533   return sals;
2534 }
2535 \f
2536 void
2537 _initialize_breakpoint ()
2538 {
2539   breakpoint_chain = 0;
2540   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
2541      before a breakpoint is set.  */
2542   breakpoint_count = 0;
2543
2544   add_com ("ignore", class_breakpoint, ignore_command,
2545            "Set ignore-count of breakpoint number N to COUNT.");
2546
2547   add_com ("commands", class_breakpoint, commands_command,
2548            "Set commands to be executed when a breakpoint is hit.\n\
2549 Give breakpoint number as argument after \"commands\".\n\
2550 With no argument, the targeted breakpoint is the last one set.\n\
2551 The commands themselves follow starting on the next line.\n\
2552 Type a line containing \"end\" to indicate the end of them.\n\
2553 Give \"silent\" as the first line to make the breakpoint silent;\n\
2554 then no output is printed when it is hit, except what the commands print.");
2555
2556   add_com ("condition", class_breakpoint, condition_command,
2557            "Specify breakpoint number N to break only if COND is true.\n\
2558 N is an integer; COND is an expression to be evaluated whenever\n\
2559 breakpoint N is reached.  ");
2560
2561   add_com ("tbreak", class_breakpoint, tbreak_command,
2562            "Set a temporary breakpoint.  Args like \"break\" command.\n\
2563 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2564 so it will be disabled when hit.  Equivalent to \"break\" followed\n\
2565 by using \"enable once\" on the breakpoint number.");
2566
2567   add_prefix_cmd ("enable", class_breakpoint, enable_command,
2568                   "Enable some breakpoints.\n\
2569 Give breakpoint numbers (separated by spaces) as arguments.\n\
2570 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2571 This is used to cancel the effect of the \"disable\" command.\n\
2572 With a subcommand you can enable temporarily.",
2573                   &enablelist, "enable ", 1, &cmdlist);
2574
2575   add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
2576                   "Enable some breakpoints.\n\
2577 Give breakpoint numbers (separated by spaces) as arguments.\n\
2578 This is used to cancel the effect of the \"disable\" command.\n\
2579 May be abbreviated to simply \"enable\".\n",
2580                   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
2581
2582   add_cmd ("once", no_class, enable_once_command,
2583            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
2584 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2585 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2586            &enablebreaklist);
2587
2588   add_cmd ("delete", no_class, enable_delete_command,
2589            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
2590 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2591            &enablebreaklist);
2592
2593   add_cmd ("delete", no_class, enable_delete_command,
2594            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
2595 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2596            &enablelist);
2597
2598   add_cmd ("once", no_class, enable_once_command,
2599            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
2600 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2601 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2602            &enablelist);
2603
2604   add_prefix_cmd ("disable", class_breakpoint, disable_command,
2605            "Disable some breakpoints.\n\
2606 Arguments are breakpoint numbers with spaces in between.\n\
2607 To disable all breakpoints, give no argument.\n\
2608 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
2609                   &disablelist, "disable ", 1, &cmdlist);
2610   add_com_alias ("dis", "disable", class_breakpoint, 1);
2611   add_com_alias ("disa", "disable", class_breakpoint, 1);
2612
2613   add_cmd ("breakpoints", class_alias, disable_command,
2614            "Disable some breakpoints.\n\
2615 Arguments are breakpoint numbers with spaces in between.\n\
2616 To disable all breakpoints, give no argument.\n\
2617 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
2618 This command may be abbreviated \"disable\".",
2619            &disablelist);
2620
2621   add_prefix_cmd ("delete", class_breakpoint, delete_command,
2622            "Delete some breakpoints or auto-display expressions.\n\
2623 Arguments are breakpoint numbers with spaces in between.\n\
2624 To delete all breakpoints, give no argument.\n\
2625 \n\
2626 Also a prefix command for deletion of other GDB objects.\n\
2627 The \"unset\" command is also an alias for \"delete\".",
2628                   &deletelist, "delete ", 1, &cmdlist);
2629   add_com_alias ("d", "delete", class_breakpoint, 1);
2630
2631   add_cmd ("breakpoints", class_alias, delete_command,
2632            "Delete some breakpoints or auto-display expressions.\n\
2633 Arguments are breakpoint numbers with spaces in between.\n\
2634 To delete all breakpoints, give no argument.\n\
2635 This command may be abbreviated \"delete\".",
2636            &deletelist);
2637
2638   add_com ("clear", class_breakpoint, clear_command,
2639            "Clear breakpoint at specified line or function.\n\
2640 Argument may be line number, function name, or \"*\" and an address.\n\
2641 If line number is specified, all breakpoints in that line are cleared.\n\
2642 If function is specified, breakpoints at beginning of function are cleared.\n\
2643 If an address is specified, breakpoints at that address are cleared.\n\n\
2644 With no argument, clears all breakpoints in the line that the selected frame\n\
2645 is executing in.\n\
2646 \n\
2647 See also the \"delete\" command which clears breakpoints by number.");
2648
2649   add_com ("break", class_breakpoint, break_command,
2650            "Set breakpoint at specified line or function.\n\
2651 Argument may be line number, function name, or \"*\" and an address.\n\
2652 If line number is specified, break at start of code for that line.\n\
2653 If function is specified, break at start of code for that function.\n\
2654 If an address is specified, break at that exact address.\n\
2655 With no arg, uses current execution address of selected stack frame.\n\
2656 This is useful for breaking on return to a stack frame.\n\
2657 \n\
2658 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2659 \n\
2660 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2661   add_com_alias ("b", "break", class_run, 1);
2662   add_com_alias ("br", "break", class_run, 1);
2663   add_com_alias ("bre", "break", class_run, 1);
2664   add_com_alias ("brea", "break", class_run, 1);
2665
2666   add_info ("breakpoints", breakpoints_info,
2667             "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
2668 The \"Type\" column indicates one of:\n\
2669 \tbreakpoint     - normal breakpoint\n\
2670 \twatchpoint     - watchpoint\n\
2671 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2672 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
2673 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
2674 address and file/line number respectively.\n\n\
2675 Convenience variable \"$_\" and default examine address for \"x\"\n\
2676 are set to the address of the last breakpoint listed.\n\n\
2677 Convenience variable \"$bpnum\" contains the number of the last\n\
2678 breakpoint set.");
2679
2680 #if MAINTENANCE_CMDS
2681
2682   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
2683             "Status of all breakpoints, or breakpoint number NUMBER.\n\
2684 The \"Type\" column indicates one of:\n\
2685 \tbreakpoint     - normal breakpoint\n\
2686 \twatchpoint     - watchpoint\n\
2687 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
2688 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
2689 \tuntil          - internal breakpoint used by the \"until\" command\n\
2690 \tfinish         - internal breakpoint used by the \"finish\" command\n\
2691 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2692 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
2693 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
2694 address and file/line number respectively.\n\n\
2695 Convenience variable \"$_\" and default examine address for \"x\"\n\
2696 are set to the address of the last breakpoint listed.\n\n\
2697 Convenience variable \"$bpnum\" contains the number of the last\n\
2698 breakpoint set.",
2699            &maintenanceinfolist);
2700
2701 #endif  /* MAINTENANCE_CMDS */
2702
2703   add_com ("catch", class_breakpoint, catch_command,
2704          "Set breakpoints to catch exceptions that are raised.\n\
2705 Argument may be a single exception to catch, multiple exceptions\n\
2706 to catch, or the default exception \"default\".  If no arguments\n\
2707 are given, breakpoints are set at all exception handlers catch clauses\n\
2708 within the current scope.\n\
2709 \n\
2710 A condition specified for the catch applies to all breakpoints set\n\
2711 with this command\n\
2712 \n\
2713 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2714
2715   add_com ("watch", class_breakpoint, watch_command,
2716            "Set a watchpoint for an expression.\n\
2717 A watchpoint stops execution of your program whenever the value of\n\
2718 an expression changes.");
2719
2720   add_info ("watchpoints", breakpoints_info,
2721             "Synonym for ``info breakpoints''.");
2722 }
2723
2724 /* OK, when we call objfile_relocate, we need to relocate breakpoints
2725    too.  breakpoint_re_set is not a good choice--for example, if
2726    addr_string contains just a line number without a file name the
2727    breakpoint might get set in a different file.  In general, there is
2728    no need to go all the way back to the user's string (though this might
2729    work if some effort were made to canonicalize it), since symtabs and
2730    everything except addresses are still valid.
2731
2732    Probably the best way to solve this is to have each breakpoint save
2733    the objfile and the section number that was used to set it (if set
2734    by "*addr", probably it is best to use find_pc_line to get a symtab
2735    and use the objfile and block_line_section for that symtab).  Then
2736    objfile_relocate can call fixup_breakpoints with the objfile and
2737    the new_offsets, and it can relocate only the appropriate breakpoints.  */
2738
2739 #ifdef IBM6000_TARGET
2740 /* But for now, just kludge it based on the concept that before an
2741    objfile is relocated the breakpoint is below 0x10000000, and afterwards
2742    it is higher, so that way we only relocate each breakpoint once.  */
2743
2744 void
2745 fixup_breakpoints (low, high, delta)
2746   CORE_ADDR low;
2747   CORE_ADDR high;
2748   CORE_ADDR delta;
2749 {
2750   struct breakpoint *b;
2751
2752   ALL_BREAKPOINTS (b)
2753     {
2754      if (b->address >= low && b->address <= high)
2755        b->address += delta;
2756     }
2757 }
2758 #endif