* breakpoint.c (breakpoint_re_set): Avoid setting source symtab
[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.)
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 && !strcmp ("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_demangled (SYMBOL_NAME (sym), stdout, 
1055                                      DMGL_ANSI | DMGL_PARAMS);
1056                     fputs_filtered (" at ", stdout);
1057                   }
1058                 fputs_filtered (b->symtab->filename, stdout);
1059                 printf_filtered (":%d", b->line_number);
1060               }
1061             else
1062               print_address_symbolic (b->address, stdout, demangle, " ");
1063           }
1064
1065         printf_filtered ("\n");
1066
1067         if (b->frame)
1068           printf_filtered ("\tstop only in stack frame at %s\n",
1069                            local_hex_string(b->frame));
1070         if (b->cond)
1071           {
1072             printf_filtered ("\tstop only if ");
1073             print_expression (b->cond, stdout);
1074             printf_filtered ("\n");
1075           }
1076         if (b->ignore_count)
1077           printf_filtered ("\tignore next %d hits\n", b->ignore_count);
1078         if ((l = b->commands))
1079           while (l)
1080             {
1081               fputs_filtered ("\t", stdout);
1082               fputs_filtered (l->line, stdout);
1083               fputs_filtered ("\n", stdout);
1084               l = l->next;
1085             }
1086       }
1087
1088   if (!found_a_breakpoint
1089       && bnum != -1)
1090     printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
1091   else
1092     /* Compare against (CORE_ADDR)-1 in case some compiler decides
1093        that a comparison of an unsigned with -1 is always false.  */
1094     if (last_addr != (CORE_ADDR)-1)
1095       set_next_address (last_addr);
1096 }
1097
1098 /* ARGSUSED */
1099 static void
1100 breakpoints_info (bnum_exp, from_tty)
1101      char *bnum_exp;
1102      int from_tty;
1103 {
1104   int bnum = -1;
1105
1106   if (bnum_exp)
1107     bnum = parse_and_eval_address (bnum_exp);
1108
1109   breakpoint_1 (bnum, 0);
1110 }
1111
1112 #if MAINTENANCE_CMDS
1113
1114 /* ARGSUSED */
1115 static void
1116 maintenance_info_breakpoints (bnum_exp, from_tty)
1117      char *bnum_exp;
1118      int from_tty;
1119 {
1120   int bnum = -1;
1121
1122   if (bnum_exp)
1123     bnum = parse_and_eval_address (bnum_exp);
1124
1125   breakpoint_1 (bnum, 1);
1126 }
1127
1128 #endif
1129
1130 /* Print a message describing any breakpoints set at PC.  */
1131
1132 static void
1133 describe_other_breakpoints (pc)
1134      register CORE_ADDR pc;
1135 {
1136   register int others = 0;
1137   register struct breakpoint *b;
1138
1139   ALL_BREAKPOINTS (b)
1140     if (b->address == pc)
1141       others++;
1142   if (others > 0)
1143     {
1144       printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
1145       ALL_BREAKPOINTS (b)
1146         if (b->address == pc)
1147           {
1148             others--;
1149             printf ("%d%s%s ",
1150                     b->number,
1151                     (b->enable == disabled) ? " (disabled)" : "",
1152                     (others > 1) ? "," : ((others == 1) ? " and" : ""));
1153           }
1154       printf ("also set at pc %s.\n", local_hex_string(pc));
1155     }
1156 }
1157 \f
1158 /* Set the default place to put a breakpoint
1159    for the `break' command with no arguments.  */
1160
1161 void
1162 set_default_breakpoint (valid, addr, symtab, line)
1163      int valid;
1164      CORE_ADDR addr;
1165      struct symtab *symtab;
1166      int line;
1167 {
1168   default_breakpoint_valid = valid;
1169   default_breakpoint_address = addr;
1170   default_breakpoint_symtab = symtab;
1171   default_breakpoint_line = line;
1172 }
1173
1174 /* Rescan breakpoints at address ADDRESS,
1175    marking the first one as "first" and any others as "duplicates".
1176    This is so that the bpt instruction is only inserted once.  */
1177
1178 static void
1179 check_duplicates (address)
1180      CORE_ADDR address;
1181 {
1182   register struct breakpoint *b;
1183   register int count = 0;
1184
1185   if (address == 0)             /* Watchpoints are uninteresting */
1186     return;
1187
1188   ALL_BREAKPOINTS (b)
1189     if (b->enable != disabled && b->address == address)
1190       {
1191         count++;
1192         b->duplicate = count > 1;
1193       }
1194 }
1195
1196 /* Low level routine to set a breakpoint.
1197    Takes as args the three things that every breakpoint must have.
1198    Returns the breakpoint object so caller can set other things.
1199    Does not set the breakpoint number!
1200    Does not print anything.
1201
1202    ==> This routine should not be called if there is a chance of later
1203    error(); otherwise it leaves a bogus breakpoint on the chain.  Validate
1204    your arguments BEFORE calling this routine!  */
1205
1206 static struct breakpoint *
1207 set_raw_breakpoint (sal)
1208      struct symtab_and_line sal;
1209 {
1210   register struct breakpoint *b, *b1;
1211
1212   b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
1213   memset (b, 0, sizeof (*b));
1214   b->address = sal.pc;
1215   b->symtab = sal.symtab;
1216   b->line_number = sal.line;
1217   b->enable = enabled;
1218   b->next = 0;
1219   b->silent = 0;
1220   b->ignore_count = 0;
1221   b->commands = NULL;
1222   b->frame = 0;
1223
1224   /* Add this breakpoint to the end of the chain
1225      so that a list of breakpoints will come out in order
1226      of increasing numbers.  */
1227
1228   b1 = breakpoint_chain;
1229   if (b1 == 0)
1230     breakpoint_chain = b;
1231   else
1232     {
1233       while (b1->next)
1234         b1 = b1->next;
1235       b1->next = b;
1236     }
1237
1238   check_duplicates (sal.pc);
1239
1240   return b;
1241 }
1242
1243 static void
1244 create_longjmp_breakpoint(func_name)
1245      char *func_name;
1246 {
1247   struct symtab_and_line sal;
1248   struct breakpoint *b;
1249   static int internal_breakpoint_number = -1;
1250
1251   if (func_name != NULL)
1252     {
1253       struct minimal_symbol *m;
1254
1255       m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
1256       if (m)
1257         sal.pc = m->address;
1258       else
1259         return;
1260     }
1261   else
1262     sal.pc = 0;
1263
1264   sal.symtab = NULL;
1265   sal.line = 0;
1266
1267   b = set_raw_breakpoint(sal);
1268   if (!b) return;
1269
1270   b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
1271   b->disposition = donttouch;
1272   b->enable = disabled;
1273   b->silent = 1;
1274   if (func_name)
1275     b->addr_string = strsave(func_name);
1276   b->number = internal_breakpoint_number--;
1277 }
1278
1279 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1280    a longjmp().  When we hit that breakpoint, call
1281    set_longjmp_resume_breakpoint() to figure out where we are going. */
1282
1283 void
1284 enable_longjmp_breakpoint()
1285 {
1286   register struct breakpoint *b;
1287
1288   ALL_BREAKPOINTS (b)
1289     if (b->type == bp_longjmp)
1290       {
1291         b->enable = enabled;
1292         check_duplicates (b->address);
1293       }
1294 }
1295
1296 void
1297 disable_longjmp_breakpoint()
1298 {
1299   register struct breakpoint *b;
1300
1301   ALL_BREAKPOINTS (b)
1302     if (   b->type == bp_longjmp
1303         || b->type == bp_longjmp_resume)
1304       {
1305         b->enable = disabled;
1306         check_duplicates (b->address);
1307       }
1308 }
1309
1310 /* Call this after hitting the longjmp() breakpoint.  Use this to set a new
1311    breakpoint at the target of the jmp_buf.
1312
1313    FIXME - This ought to be done by setting a temporary breakpoint that gets
1314    deleted automatically...
1315 */
1316
1317 void
1318 set_longjmp_resume_breakpoint(pc, frame)
1319      CORE_ADDR pc;
1320      FRAME frame;
1321 {
1322   register struct breakpoint *b;
1323
1324   ALL_BREAKPOINTS (b)
1325     if (b->type == bp_longjmp_resume)
1326       {
1327         b->address = pc;
1328         b->enable = enabled;
1329         if (frame != NULL)
1330           b->frame = FRAME_FP(frame);
1331         else
1332           b->frame = 0;
1333         check_duplicates (b->address);
1334         return;
1335       }
1336 }
1337
1338 /* Set a breakpoint that will evaporate an end of command
1339    at address specified by SAL.
1340    Restrict it to frame FRAME if FRAME is nonzero.  */
1341
1342 struct breakpoint *
1343 set_momentary_breakpoint (sal, frame, type)
1344      struct symtab_and_line sal;
1345      FRAME frame;
1346      enum bptype type;
1347 {
1348   register struct breakpoint *b;
1349   b = set_raw_breakpoint (sal);
1350   b->type = type;
1351   b->enable = enabled;
1352   b->disposition = donttouch;
1353   b->frame = (frame ? FRAME_FP (frame) : 0);
1354   return b;
1355 }
1356
1357 #if 0
1358 void
1359 clear_momentary_breakpoints ()
1360 {
1361   register struct breakpoint *b;
1362   ALL_BREAKPOINTS (b)
1363     if (b->disposition == delete)
1364       {
1365         delete_breakpoint (b);
1366         break;
1367       }
1368 }
1369 #endif
1370 \f
1371 /* Tell the user we have just set a breakpoint B.  */
1372 static void
1373 mention (b)
1374      struct breakpoint *b;
1375 {
1376   switch (b->type)
1377     {
1378     case bp_watchpoint:
1379       printf_filtered ("Watchpoint %d: ", b->number);
1380       print_expression (b->exp, stdout);
1381       break;
1382     case bp_breakpoint:
1383       printf_filtered ("Breakpoint %d at %s", b->number,
1384                        local_hex_string(b->address));
1385       if (b->symtab)
1386         printf_filtered (": file %s, line %d.",
1387                          b->symtab->filename, b->line_number);
1388       break;
1389     case bp_until:
1390     case bp_finish:
1391     case bp_longjmp:
1392     case bp_longjmp_resume:
1393       break;
1394     }
1395   printf_filtered ("\n");
1396 }
1397
1398 #if 0
1399 /* Nobody calls this currently. */
1400 /* Set a breakpoint from a symtab and line.
1401    If TEMPFLAG is nonzero, it is a temporary breakpoint.
1402    ADDR_STRING is a malloc'd string holding the name of where we are
1403    setting the breakpoint.  This is used later to re-set it after the
1404    program is relinked and symbols are reloaded.
1405    Print the same confirmation messages that the breakpoint command prints.  */
1406
1407 void
1408 set_breakpoint (s, line, tempflag, addr_string)
1409      struct symtab *s;
1410      int line;
1411      int tempflag;
1412      char *addr_string;
1413 {
1414   register struct breakpoint *b;
1415   struct symtab_and_line sal;
1416   
1417   sal.symtab = s;
1418   sal.line = line;
1419   sal.pc = 0;
1420   resolve_sal_pc (&sal);                        /* Might error out */
1421   describe_other_breakpoints (sal.pc);
1422
1423   b = set_raw_breakpoint (sal);
1424   set_breakpoint_count (breakpoint_count + 1);
1425   b->number = breakpoint_count;
1426   b->type = bp_breakpoint;
1427   b->cond = 0;
1428   b->addr_string = addr_string;
1429   b->enable = enabled;
1430   b->disposition = tempflag ? delete : donttouch;
1431
1432   mention (b);
1433 }
1434 #endif /* 0 */
1435 \f
1436 /* Set a breakpoint according to ARG (function, linenum or *address)
1437    and make it temporary if TEMPFLAG is nonzero. */
1438
1439 static void
1440 break_command_1 (arg, tempflag, from_tty)
1441      char *arg;
1442      int tempflag, from_tty;
1443 {
1444   struct symtabs_and_lines sals;
1445   struct symtab_and_line sal;
1446   register struct expression *cond = 0;
1447   register struct breakpoint *b;
1448
1449   /* Pointers in arg to the start, and one past the end, of the condition.  */
1450   char *cond_start = NULL;
1451   char *cond_end;
1452   /* Pointers in arg to the start, and one past the end,
1453      of the address part.  */
1454   char *addr_start = NULL;
1455   char *addr_end;
1456   
1457   int i;
1458
1459   sals.sals = NULL;
1460   sals.nelts = 0;
1461
1462   sal.line = sal.pc = sal.end = 0;
1463   sal.symtab = 0;
1464
1465   /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1466
1467   if (!arg || (arg[0] == 'i' && arg[1] == 'f' 
1468                && (arg[2] == ' ' || arg[2] == '\t')))
1469     {
1470       if (default_breakpoint_valid)
1471         {
1472           sals.sals = (struct symtab_and_line *) 
1473             xmalloc (sizeof (struct symtab_and_line));
1474           sal.pc = default_breakpoint_address;
1475           sal.line = default_breakpoint_line;
1476           sal.symtab = default_breakpoint_symtab;
1477           sals.sals[0] = sal;
1478           sals.nelts = 1;
1479         }
1480       else
1481         error ("No default breakpoint address now.");
1482     }
1483   else
1484     {
1485       addr_start = arg;
1486
1487       /* Force almost all breakpoints to be in terms of the
1488          current_source_symtab (which is decode_line_1's default).  This
1489          should produce the results we want almost all of the time while
1490          leaving default_breakpoint_* alone.  */
1491       if (default_breakpoint_valid
1492           && (!current_source_symtab
1493               || (arg && (*arg == '+' || *arg == '-'))))
1494         sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1495                               default_breakpoint_line);
1496       else
1497         sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1498
1499       addr_end = arg;
1500     }
1501   
1502   if (! sals.nelts) 
1503     return;
1504
1505   /* Resolve all line numbers to PC's, and verify that conditions
1506      can be parsed, before setting any breakpoints.  */
1507   for (i = 0; i < sals.nelts; i++)
1508     {
1509       resolve_sal_pc (&sals.sals[i]);
1510       
1511       while (arg && *arg)
1512         {
1513           if (arg[0] == 'i' && arg[1] == 'f'
1514               && (arg[2] == ' ' || arg[2] == '\t'))
1515             {
1516               arg += 2;
1517               cond_start = arg;
1518               cond = parse_exp_1 (&arg, block_for_pc (sals.sals[i].pc), 0);
1519               cond_end = arg;
1520             }
1521           else
1522             error ("Junk at end of arguments.");
1523         }
1524     }
1525
1526   /* Now set all the breakpoints.  */
1527   for (i = 0; i < sals.nelts; i++)
1528     {
1529       sal = sals.sals[i];
1530
1531       if (from_tty)
1532         describe_other_breakpoints (sal.pc);
1533
1534       b = set_raw_breakpoint (sal);
1535       set_breakpoint_count (breakpoint_count + 1);
1536       b->number = breakpoint_count;
1537       b->type = bp_breakpoint;
1538       b->cond = cond;
1539       
1540       if (addr_start)
1541         b->addr_string = savestring (addr_start, addr_end - addr_start);
1542       if (cond_start)
1543         b->cond_string = savestring (cond_start, cond_end - cond_start);
1544                                      
1545       b->enable = enabled;
1546       b->disposition = tempflag ? delete : donttouch;
1547
1548       mention (b);
1549     }
1550
1551   if (sals.nelts > 1)
1552     {
1553       printf ("Multiple breakpoints were set.\n");
1554       printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1555     }
1556   free ((PTR)sals.sals);
1557 }
1558
1559 /* Helper function for break_command_1 and disassemble_command.  */
1560
1561 void
1562 resolve_sal_pc (sal)
1563      struct symtab_and_line *sal;
1564 {
1565   CORE_ADDR pc;
1566
1567   if (sal->pc == 0 && sal->symtab != 0)
1568     {
1569       pc = find_line_pc (sal->symtab, sal->line);
1570       if (pc == 0)
1571         error ("No line %d in file \"%s\".",
1572                sal->line, sal->symtab->filename);
1573       sal->pc = pc;
1574     }
1575 }
1576
1577 void
1578 break_command (arg, from_tty)
1579      char *arg;
1580      int from_tty;
1581 {
1582   break_command_1 (arg, 0, from_tty);
1583 }
1584
1585 static void
1586 tbreak_command (arg, from_tty)
1587      char *arg;
1588      int from_tty;
1589 {
1590   break_command_1 (arg, 1, from_tty);
1591 }
1592
1593 /* ARGSUSED */
1594 static void
1595 watch_command (arg, from_tty)
1596      char *arg;
1597      int from_tty;
1598 {
1599   struct breakpoint *b;
1600   struct symtab_and_line sal;
1601   struct expression *exp;
1602   struct block *exp_valid_block;
1603   struct value *val;
1604
1605   sal.pc = 0;
1606   sal.symtab = NULL;
1607   sal.line = 0;
1608   
1609   /* Parse arguments.  */
1610   innermost_block = NULL;
1611   exp = parse_expression (arg);
1612   exp_valid_block = innermost_block;
1613   val = evaluate_expression (exp);
1614   release_value (val);
1615
1616   /* Now set up the breakpoint.  */
1617   b = set_raw_breakpoint (sal);
1618   set_breakpoint_count (breakpoint_count + 1);
1619   b->number = breakpoint_count;
1620   b->type = bp_watchpoint;
1621   b->disposition = donttouch;
1622   b->exp = exp;
1623   b->exp_valid_block = exp_valid_block;
1624   b->val = val;
1625   b->cond = 0;
1626   b->cond_string = NULL;
1627   mention (b);
1628 }
1629 \f
1630 /*
1631  * Helper routine for the until_command routine in infcmd.c.  Here
1632  * because it uses the mechanisms of breakpoints.
1633  */
1634 /* ARGSUSED */
1635 void
1636 until_break_command (arg, from_tty)
1637      char *arg;
1638      int from_tty;
1639 {
1640   struct symtabs_and_lines sals;
1641   struct symtab_and_line sal;
1642   FRAME prev_frame = get_prev_frame (selected_frame);
1643   struct breakpoint *breakpoint;
1644   struct cleanup *old_chain;
1645
1646   clear_proceed_status ();
1647
1648   /* Set a breakpoint where the user wants it and at return from
1649      this function */
1650   
1651   if (default_breakpoint_valid)
1652     sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1653                           default_breakpoint_line);
1654   else
1655     sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1656   
1657   if (sals.nelts != 1)
1658     error ("Couldn't get information on specified line.");
1659   
1660   sal = sals.sals[0];
1661   free ((PTR)sals.sals);                /* malloc'd, so freed */
1662   
1663   if (*arg)
1664     error ("Junk at end of arguments.");
1665   
1666   resolve_sal_pc (&sal);
1667   
1668   breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
1669   
1670   old_chain = make_cleanup(delete_breakpoint, breakpoint);
1671
1672   /* Keep within the current frame */
1673   
1674   if (prev_frame)
1675     {
1676       struct frame_info *fi;
1677       
1678       fi = get_frame_info (prev_frame);
1679       sal = find_pc_line (fi->pc, 0);
1680       sal.pc = fi->pc;
1681       breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
1682       make_cleanup(delete_breakpoint, breakpoint);
1683     }
1684   
1685   proceed (-1, -1, 0);
1686   do_cleanups(old_chain);
1687 }
1688 \f
1689 #if 0
1690 /* These aren't used; I don't konw what they were for.  */
1691 /* Set a breakpoint at the catch clause for NAME.  */
1692 static int
1693 catch_breakpoint (name)
1694      char *name;
1695 {
1696 }
1697
1698 static int
1699 disable_catch_breakpoint ()
1700 {
1701 }
1702
1703 static int
1704 delete_catch_breakpoint ()
1705 {
1706 }
1707
1708 static int
1709 enable_catch_breakpoint ()
1710 {
1711 }
1712 #endif /* 0 */
1713
1714 struct sal_chain
1715 {
1716   struct sal_chain *next;
1717   struct symtab_and_line sal;
1718 };
1719
1720 #if 0
1721 /* This isn't used; I don't know what it was for.  */
1722 /* For each catch clause identified in ARGS, run FUNCTION
1723    with that clause as an argument.  */
1724 static struct symtabs_and_lines
1725 map_catch_names (args, function)
1726      char *args;
1727      int (*function)();
1728 {
1729   register char *p = args;
1730   register char *p1;
1731   struct symtabs_and_lines sals;
1732 #if 0
1733   struct sal_chain *sal_chain = 0;
1734 #endif
1735
1736   if (p == 0)
1737     error_no_arg ("one or more catch names");
1738
1739   sals.nelts = 0;
1740   sals.sals = NULL;
1741
1742   while (*p)
1743     {
1744       p1 = p;
1745       /* Don't swallow conditional part.  */
1746       if (p1[0] == 'i' && p1[1] == 'f'
1747           && (p1[2] == ' ' || p1[2] == '\t'))
1748         break;
1749
1750       if (isalpha (*p1))
1751         {
1752           p1++;
1753           while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
1754             p1++;
1755         }
1756
1757       if (*p1 && *p1 != ' ' && *p1 != '\t')
1758         error ("Arguments must be catch names.");
1759
1760       *p1 = 0;
1761 #if 0
1762       if (function (p))
1763         {
1764           struct sal_chain *next
1765             = (struct sal_chain *)alloca (sizeof (struct sal_chain));
1766           next->next = sal_chain;
1767           next->sal = get_catch_sal (p);
1768           sal_chain = next;
1769           goto win;
1770         }
1771 #endif
1772       printf ("No catch clause for exception %s.\n", p);
1773 #if 0
1774     win:
1775 #endif
1776       p = p1;
1777       while (*p == ' ' || *p == '\t') p++;
1778     }
1779 }
1780 #endif /* 0 */
1781
1782 /* This shares a lot of code with `print_frame_label_vars' from stack.c.  */
1783
1784 static struct symtabs_and_lines
1785 get_catch_sals (this_level_only)
1786      int this_level_only;
1787 {
1788   register struct blockvector *bl;
1789   register struct block *block;
1790   int index, have_default = 0;
1791   struct frame_info *fi;
1792   CORE_ADDR pc;
1793   struct symtabs_and_lines sals;
1794   struct sal_chain *sal_chain = 0;
1795   char *blocks_searched;
1796
1797   /* Not sure whether an error message is always the correct response,
1798      but it's better than a core dump.  */
1799   if (selected_frame == NULL)
1800     error ("No selected frame.");
1801   block = get_frame_block (selected_frame);
1802   fi = get_frame_info (selected_frame);
1803   pc = fi->pc;
1804
1805   sals.nelts = 0;
1806   sals.sals = NULL;
1807
1808   if (block == 0)
1809     error ("No symbol table info available.\n");
1810
1811   bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1812   blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1813   memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1814
1815   while (block != 0)
1816     {
1817       CORE_ADDR end = BLOCK_END (block) - 4;
1818       int last_index;
1819
1820       if (bl != blockvector_for_pc (end, &index))
1821         error ("blockvector blotch");
1822       if (BLOCKVECTOR_BLOCK (bl, index) != block)
1823         error ("blockvector botch");
1824       last_index = BLOCKVECTOR_NBLOCKS (bl);
1825       index += 1;
1826
1827       /* Don't print out blocks that have gone by.  */
1828       while (index < last_index
1829              && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1830         index++;
1831
1832       while (index < last_index
1833              && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1834         {
1835           if (blocks_searched[index] == 0)
1836             {
1837               struct block *b = BLOCKVECTOR_BLOCK (bl, index);
1838               int nsyms;
1839               register int i;
1840               register struct symbol *sym;
1841
1842               nsyms = BLOCK_NSYMS (b);
1843
1844               for (i = 0; i < nsyms; i++)
1845                 {
1846                   sym = BLOCK_SYM (b, i);
1847                   if (! strcmp (SYMBOL_NAME (sym), "default"))
1848                     {
1849                       if (have_default)
1850                         continue;
1851                       have_default = 1;
1852                     }
1853                   if (SYMBOL_CLASS (sym) == LOC_LABEL)
1854                     {
1855                       struct sal_chain *next = (struct sal_chain *)
1856                         alloca (sizeof (struct sal_chain));
1857                       next->next = sal_chain;
1858                       next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1859                       sal_chain = next;
1860                     }
1861                 }
1862               blocks_searched[index] = 1;
1863             }
1864           index++;
1865         }
1866       if (have_default)
1867         break;
1868       if (sal_chain && this_level_only)
1869         break;
1870
1871       /* After handling the function's top-level block, stop.
1872          Don't continue to its superblock, the block of
1873          per-file symbols.  */
1874       if (BLOCK_FUNCTION (block))
1875         break;
1876       block = BLOCK_SUPERBLOCK (block);
1877     }
1878
1879   if (sal_chain)
1880     {
1881       struct sal_chain *tmp_chain;
1882
1883       /* Count the number of entries.  */
1884       for (index = 0, tmp_chain = sal_chain; tmp_chain;
1885            tmp_chain = tmp_chain->next)
1886         index++;
1887
1888       sals.nelts = index;
1889       sals.sals = (struct symtab_and_line *)
1890         xmalloc (index * sizeof (struct symtab_and_line));
1891       for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
1892         sals.sals[index] = sal_chain->sal;
1893     }
1894
1895   return sals;
1896 }
1897
1898 /* Commands to deal with catching exceptions.  */
1899
1900 static void
1901 catch_command_1 (arg, tempflag, from_tty)
1902      char *arg;
1903      int tempflag;
1904      int from_tty;
1905 {
1906   /* First, translate ARG into something we can deal with in terms
1907      of breakpoints.  */
1908
1909   struct symtabs_and_lines sals;
1910   struct symtab_and_line sal;
1911   register struct expression *cond = 0;
1912   register struct breakpoint *b;
1913   char *save_arg;
1914   int i;
1915
1916   sal.line = sal.pc = sal.end = 0;
1917   sal.symtab = 0;
1918
1919   /* If no arg given, or if first arg is 'if ', all active catch clauses
1920      are breakpointed. */
1921
1922   if (!arg || (arg[0] == 'i' && arg[1] == 'f' 
1923                && (arg[2] == ' ' || arg[2] == '\t')))
1924     {
1925       /* Grab all active catch clauses.  */
1926       sals = get_catch_sals (0);
1927     }
1928   else
1929     {
1930       /* Grab selected catch clauses.  */
1931       error ("catch NAME not implemeneted");
1932 #if 0
1933       /* This isn't used; I don't know what it was for.  */
1934       sals = map_catch_names (arg, catch_breakpoint);
1935 #endif
1936     }
1937
1938   if (! sals.nelts) 
1939     return;
1940
1941   save_arg = arg;
1942   for (i = 0; i < sals.nelts; i++)
1943     {
1944       resolve_sal_pc (&sals.sals[i]);
1945       
1946       while (arg && *arg)
1947         {
1948           if (arg[0] == 'i' && arg[1] == 'f'
1949               && (arg[2] == ' ' || arg[2] == '\t'))
1950             cond = parse_exp_1 ((arg += 2, &arg), 
1951                                 block_for_pc (sals.sals[i].pc), 0);
1952           else
1953             error ("Junk at end of arguments.");
1954         }
1955       arg = save_arg;
1956     }
1957
1958   for (i = 0; i < sals.nelts; i++)
1959     {
1960       sal = sals.sals[i];
1961
1962       if (from_tty)
1963         describe_other_breakpoints (sal.pc);
1964
1965       b = set_raw_breakpoint (sal);
1966       set_breakpoint_count (breakpoint_count + 1);
1967       b->number = breakpoint_count;
1968       b->type = bp_breakpoint;
1969       b->cond = cond;
1970       b->enable = enabled;
1971       b->disposition = tempflag ? delete : donttouch;
1972
1973       printf ("Breakpoint %d at %s", b->number, local_hex_string(b->address));
1974       if (b->symtab)
1975         printf (": file %s, line %d.", b->symtab->filename, b->line_number);
1976       printf ("\n");
1977     }
1978
1979   if (sals.nelts > 1)
1980     {
1981       printf ("Multiple breakpoints were set.\n");
1982       printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1983     }
1984   free ((PTR)sals.sals);
1985 }
1986
1987 #if 0
1988 /* These aren't used; I don't know what they were for.  */
1989 /* Disable breakpoints on all catch clauses described in ARGS.  */
1990 static void
1991 disable_catch (args)
1992      char *args;
1993 {
1994   /* Map the disable command to catch clauses described in ARGS.  */
1995 }
1996
1997 /* Enable breakpoints on all catch clauses described in ARGS.  */
1998 static void
1999 enable_catch (args)
2000      char *args;
2001 {
2002   /* Map the disable command to catch clauses described in ARGS.  */
2003 }
2004
2005 /* Delete breakpoints on all catch clauses in the active scope.  */
2006 static void
2007 delete_catch (args)
2008      char *args;
2009 {
2010   /* Map the delete command to catch clauses described in ARGS.  */
2011 }
2012 #endif /* 0 */
2013
2014 static void
2015 catch_command (arg, from_tty)
2016      char *arg;
2017      int from_tty;
2018 {
2019   catch_command_1 (arg, 0, from_tty);
2020 }
2021 \f
2022 static void
2023 clear_command (arg, from_tty)
2024      char *arg;
2025      int from_tty;
2026 {
2027   register struct breakpoint *b, *b1;
2028   struct symtabs_and_lines sals;
2029   struct symtab_and_line sal;
2030   register struct breakpoint *found;
2031   int i;
2032
2033   if (arg)
2034     {
2035       sals = decode_line_spec (arg, 1);
2036     }
2037   else
2038     {
2039       sals.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
2040       sal.line = default_breakpoint_line;
2041       sal.symtab = default_breakpoint_symtab;
2042       sal.pc = 0;
2043       if (sal.symtab == 0)
2044         error ("No source file specified.");
2045
2046       sals.sals[0] = sal;
2047       sals.nelts = 1;
2048     }
2049
2050   for (i = 0; i < sals.nelts; i++)
2051     {
2052       /* If exact pc given, clear bpts at that pc.
2053          But if sal.pc is zero, clear all bpts on specified line.  */
2054       sal = sals.sals[i];
2055       found = (struct breakpoint *) 0;
2056       while (breakpoint_chain
2057              && (sal.pc ? breakpoint_chain->address == sal.pc
2058                  : (breakpoint_chain->symtab == sal.symtab
2059                     && breakpoint_chain->line_number == sal.line)))
2060         {
2061           b1 = breakpoint_chain;
2062           breakpoint_chain = b1->next;
2063           b1->next = found;
2064           found = b1;
2065         }
2066
2067       ALL_BREAKPOINTS (b)
2068         while (b->next
2069                && b->next->type != bp_watchpoint
2070                && (sal.pc ? b->next->address == sal.pc
2071                    : (b->next->symtab == sal.symtab
2072                       && b->next->line_number == sal.line)))
2073           {
2074             b1 = b->next;
2075             b->next = b1->next;
2076             b1->next = found;
2077             found = b1;
2078           }
2079
2080       if (found == 0)
2081         {
2082           if (arg)
2083             error ("No breakpoint at %s.", arg);
2084           else
2085             error ("No breakpoint at this line.");
2086         }
2087
2088       if (found->next) from_tty = 1; /* Always report if deleted more than one */
2089       if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
2090       while (found)
2091         {
2092           if (from_tty) printf ("%d ", found->number);
2093           b1 = found->next;
2094           delete_breakpoint (found);
2095           found = b1;
2096         }
2097       if (from_tty) putchar ('\n');
2098     }
2099   free ((PTR)sals.sals);
2100 }
2101 \f
2102 /* Delete breakpoint in BS if they are `delete' breakpoints.
2103    This is called after any breakpoint is hit, or after errors.  */
2104
2105 void
2106 breakpoint_auto_delete (bs)
2107      bpstat bs;
2108 {
2109   for (; bs; bs = bs->next)
2110     if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete)
2111       delete_breakpoint (bs->breakpoint_at);
2112 }
2113
2114 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2115
2116 void
2117 delete_breakpoint (bpt)
2118      struct breakpoint *bpt;
2119 {
2120   register struct breakpoint *b;
2121   register bpstat bs;
2122
2123   if (bpt->inserted)
2124       target_remove_breakpoint(bpt->address, bpt->shadow_contents);
2125
2126   if (breakpoint_chain == bpt)
2127     breakpoint_chain = bpt->next;
2128
2129   ALL_BREAKPOINTS (b)
2130     if (b->next == bpt)
2131       {
2132         b->next = bpt->next;
2133         break;
2134       }
2135
2136   check_duplicates (bpt->address);
2137
2138   free_command_lines (&bpt->commands);
2139   if (bpt->cond)
2140     free ((PTR)bpt->cond);
2141   if (bpt->cond_string != NULL)
2142     free ((PTR)bpt->cond_string);
2143   if (bpt->addr_string != NULL)
2144     free ((PTR)bpt->addr_string);
2145
2146   if (xgdb_verbose && bpt->type == bp_breakpoint)
2147     printf ("breakpoint #%d deleted\n", bpt->number);
2148
2149   /* Be sure no bpstat's are pointing at it after it's been freed.  */
2150   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat for now. */
2151   for (bs = stop_bpstat; bs; bs = bs->next)
2152     if (bs->breakpoint_at == bpt)
2153       bs->breakpoint_at = NULL;
2154   free ((PTR)bpt);
2155 }
2156
2157 static void
2158 delete_command (arg, from_tty)
2159      char *arg;
2160      int from_tty;
2161 {
2162
2163   if (arg == 0)
2164     {
2165       /* Ask user only if there are some breakpoints to delete.  */
2166       if (!from_tty
2167           || (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
2168         {
2169           /* No arg; clear all breakpoints.  */
2170           while (breakpoint_chain)
2171             delete_breakpoint (breakpoint_chain);
2172         }
2173     }
2174   else
2175     map_breakpoint_numbers (arg, delete_breakpoint);
2176 }
2177
2178 /* Reset a breakpoint given it's struct breakpoint * BINT.
2179    The value we return ends up being the return value from catch_errors.
2180    Unused in this case.  */
2181
2182 static int
2183 breakpoint_re_set_one (bint)
2184      char *bint;
2185 {
2186   struct breakpoint *b = (struct breakpoint *)bint;  /* get past catch_errs */
2187   int i;
2188   struct symtabs_and_lines sals;
2189   char *s;
2190   enum enable save_enable;
2191
2192   switch (b->type)
2193     {
2194     case bp_breakpoint:
2195       if (b->addr_string == NULL)
2196         {
2197           /* Anything without a string can't be re-set. */
2198           delete_breakpoint (b);
2199           return 0;
2200         }
2201       /* In case we have a problem, disable this breakpoint.  We'll restore
2202          its status if we succeed.  */
2203       save_enable = b->enable;
2204       b->enable = disabled;
2205
2206       s = b->addr_string;
2207       sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0);
2208       for (i = 0; i < sals.nelts; i++)
2209         {
2210           resolve_sal_pc (&sals.sals[i]);
2211           if (b->symtab != sals.sals[i].symtab
2212               || b->line_number != sals.sals[i].line
2213               || b->address != sals.sals[i].pc)
2214             {
2215               b->symtab = sals.sals[i].symtab;
2216               b->line_number = sals.sals[i].line;
2217               b->address = sals.sals[i].pc;
2218
2219               if (b->cond_string != NULL)
2220                 {
2221                   s = b->cond_string;
2222                   b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
2223                 }
2224           
2225               check_duplicates (b->address);
2226
2227               mention (b);
2228             }
2229           b->enable = save_enable;      /* Restore it, this worked. */
2230         }
2231       free ((PTR)sals.sals);
2232       break;
2233     case bp_watchpoint:
2234       /* FIXME!  This is the wrong thing to do.... */
2235       delete_breakpoint (b);
2236       break;
2237     default:
2238       printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
2239     case bp_until:
2240     case bp_finish:
2241     case bp_longjmp:
2242     case bp_longjmp_resume:
2243       delete_breakpoint (b);
2244       break;
2245     }
2246
2247   return 0;
2248 }
2249
2250 /* Re-set all breakpoints after symbols have been re-loaded.  */
2251 void
2252 breakpoint_re_set ()
2253 {
2254   struct breakpoint *b, *temp;
2255   static char message1[] = "Error in re-setting breakpoint %d:\n";
2256   char message[sizeof (message1) + 30 /* slop */];
2257   
2258   /* If we have no current source symtab, and we have any breakpoints,
2259      go through the work of making a source context.  */
2260   if (current_source_symtab == NULL)
2261     {
2262       ALL_BREAKPOINTS (b)
2263       {
2264         select_source_symtab (NULL);
2265         break;                          /* We only care if there are any, and
2266                                            don't need to do it N times.  */
2267       }
2268     }
2269
2270   ALL_BREAKPOINTS_SAFE (b, temp)
2271     {
2272       sprintf (message, message1, b->number);   /* Format possible error msg */
2273       catch_errors (breakpoint_re_set_one, (char *) b, message);
2274     }
2275
2276   create_longjmp_breakpoint("longjmp");
2277   create_longjmp_breakpoint("_longjmp");
2278   create_longjmp_breakpoint("siglongjmp");
2279   create_longjmp_breakpoint(NULL);
2280
2281 #if 0
2282   /* Took this out (temporaliy at least), since it produces an extra 
2283      blank line at startup. This messes up the gdbtests. -PB */
2284   /* Blank line to finish off all those mention() messages we just printed.  */
2285   printf_filtered ("\n");
2286 #endif
2287 }
2288 \f
2289 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2290    If from_tty is nonzero, it prints a message to that effect,
2291    which ends with a period (no newline).  */
2292
2293 void
2294 set_ignore_count (bptnum, count, from_tty)
2295      int bptnum, count, from_tty;
2296 {
2297   register struct breakpoint *b;
2298
2299   if (count < 0)
2300     count = 0;
2301
2302   ALL_BREAKPOINTS (b)
2303     if (b->number == bptnum)
2304       {
2305         b->ignore_count = count;
2306         if (!from_tty)
2307           return;
2308         else if (count == 0)
2309           printf_filtered ("Will stop next time breakpoint %d is reached.",
2310                            bptnum);
2311         else if (count == 1)
2312           printf_filtered ("Will ignore next crossing of breakpoint %d.",
2313                            bptnum);
2314         else
2315           printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2316                   count, bptnum);
2317         return;
2318       }
2319
2320   error ("No breakpoint number %d.", bptnum);
2321 }
2322
2323 /* Clear the ignore counts of all breakpoints.  */
2324 void
2325 breakpoint_clear_ignore_counts ()
2326 {
2327   struct breakpoint *b;
2328
2329   ALL_BREAKPOINTS (b)
2330     b->ignore_count = 0;
2331 }
2332
2333 /* Command to set ignore-count of breakpoint N to COUNT.  */
2334
2335 static void
2336 ignore_command (args, from_tty)
2337      char *args;
2338      int from_tty;
2339 {
2340   char *p = args;
2341   register int num;
2342
2343   if (p == 0)
2344     error_no_arg ("a breakpoint number");
2345   
2346   num = get_number (&p);
2347
2348   if (*p == 0)
2349     error ("Second argument (specified ignore-count) is missing.");
2350
2351   set_ignore_count (num,
2352                     longest_to_int (value_as_long (parse_and_eval (p))),
2353                     from_tty);
2354   printf_filtered ("\n");
2355 }
2356 \f
2357 /* Call FUNCTION on each of the breakpoints
2358    whose numbers are given in ARGS.  */
2359
2360 static void
2361 map_breakpoint_numbers (args, function)
2362      char *args;
2363      void (*function) PARAMS ((struct breakpoint *));
2364 {
2365   register char *p = args;
2366   char *p1;
2367   register int num;
2368   register struct breakpoint *b;
2369
2370   if (p == 0)
2371     error_no_arg ("one or more breakpoint numbers");
2372
2373   while (*p)
2374     {
2375       p1 = p;
2376       
2377       num = get_number (&p1);
2378
2379       ALL_BREAKPOINTS (b)
2380         if (b->number == num)
2381           {
2382             function (b);
2383             goto win;
2384           }
2385       printf ("No breakpoint number %d.\n", num);
2386     win:
2387       p = p1;
2388     }
2389 }
2390
2391 static void
2392 enable_breakpoint (bpt)
2393      struct breakpoint *bpt;
2394 {
2395   bpt->enable = enabled;
2396
2397   if (xgdb_verbose && bpt->type == bp_breakpoint)
2398     printf ("breakpoint #%d enabled\n", bpt->number);
2399
2400   check_duplicates (bpt->address);
2401   if (bpt->type == bp_watchpoint)
2402     {
2403       if (bpt->exp_valid_block != NULL
2404        && !contained_in (get_selected_block (), bpt->exp_valid_block))
2405         {
2406           printf_filtered ("\
2407 Cannot enable watchpoint %d because the block in which its expression\n\
2408 is valid is not currently in scope.\n", bpt->number);
2409           return;
2410         }
2411
2412       value_free (bpt->val);
2413
2414       bpt->val = evaluate_expression (bpt->exp);
2415       release_value (bpt->val);
2416     }
2417 }
2418
2419 /* ARGSUSED */
2420 static void
2421 enable_command (args, from_tty)
2422      char *args;
2423      int from_tty;
2424 {
2425   struct breakpoint *bpt;
2426   if (args == 0)
2427     ALL_BREAKPOINTS (bpt)
2428       switch (bpt->type)
2429         {
2430         case bp_breakpoint:
2431         case bp_watchpoint:
2432           enable_breakpoint (bpt);
2433         default:
2434           continue;
2435         }
2436   else
2437     map_breakpoint_numbers (args, enable_breakpoint);
2438 }
2439
2440 static void
2441 disable_breakpoint (bpt)
2442      struct breakpoint *bpt;
2443 {
2444   bpt->enable = disabled;
2445
2446   if (xgdb_verbose && bpt->type == bp_breakpoint)
2447     printf_filtered ("breakpoint #%d disabled\n", bpt->number);
2448
2449   check_duplicates (bpt->address);
2450 }
2451
2452 /* ARGSUSED */
2453 static void
2454 disable_command (args, from_tty)
2455      char *args;
2456      int from_tty;
2457 {
2458   register struct breakpoint *bpt;
2459   if (args == 0)
2460     ALL_BREAKPOINTS (bpt)
2461       switch (bpt->type)
2462         {
2463         case bp_breakpoint:
2464         case bp_watchpoint:
2465           disable_breakpoint (bpt);
2466         default:
2467           continue;
2468         }
2469   else
2470     map_breakpoint_numbers (args, disable_breakpoint);
2471 }
2472
2473 static void
2474 enable_once_breakpoint (bpt)
2475      struct breakpoint *bpt;
2476 {
2477   bpt->enable = enabled;
2478   bpt->disposition = disable;
2479
2480   check_duplicates (bpt->address);
2481 }
2482
2483 /* ARGSUSED */
2484 static void
2485 enable_once_command (args, from_tty)
2486      char *args;
2487      int from_tty;
2488 {
2489   map_breakpoint_numbers (args, enable_once_breakpoint);
2490 }
2491
2492 static void
2493 enable_delete_breakpoint (bpt)
2494      struct breakpoint *bpt;
2495 {
2496   bpt->enable = enabled;
2497   bpt->disposition = delete;
2498
2499   check_duplicates (bpt->address);
2500 }
2501
2502 /* ARGSUSED */
2503 static void
2504 enable_delete_command (args, from_tty)
2505      char *args;
2506      int from_tty;
2507 {
2508   map_breakpoint_numbers (args, enable_delete_breakpoint);
2509 }
2510 \f
2511 /*
2512  * Use default_breakpoint_'s, or nothing if they aren't valid.
2513  */
2514 struct symtabs_and_lines
2515 decode_line_spec_1 (string, funfirstline)
2516      char *string;
2517      int funfirstline;
2518 {
2519   struct symtabs_and_lines sals;
2520   if (string == 0)
2521     error ("Empty line specification.");
2522   if (default_breakpoint_valid)
2523     sals = decode_line_1 (&string, funfirstline,
2524                           default_breakpoint_symtab, default_breakpoint_line);
2525   else
2526     sals = decode_line_1 (&string, funfirstline, (struct symtab *)NULL, 0);
2527   if (*string)
2528     error ("Junk at end of line specification: %s", string);
2529   return sals;
2530 }
2531 \f
2532 void
2533 _initialize_breakpoint ()
2534 {
2535   breakpoint_chain = 0;
2536   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
2537      before a breakpoint is set.  */
2538   breakpoint_count = 0;
2539
2540   add_com ("ignore", class_breakpoint, ignore_command,
2541            "Set ignore-count of breakpoint number N to COUNT.");
2542
2543   add_com ("commands", class_breakpoint, commands_command,
2544            "Set commands to be executed when a breakpoint is hit.\n\
2545 Give breakpoint number as argument after \"commands\".\n\
2546 With no argument, the targeted breakpoint is the last one set.\n\
2547 The commands themselves follow starting on the next line.\n\
2548 Type a line containing \"end\" to indicate the end of them.\n\
2549 Give \"silent\" as the first line to make the breakpoint silent;\n\
2550 then no output is printed when it is hit, except what the commands print.");
2551
2552   add_com ("condition", class_breakpoint, condition_command,
2553            "Specify breakpoint number N to break only if COND is true.\n\
2554 N is an integer; COND is an expression to be evaluated whenever\n\
2555 breakpoint N is reached.  ");
2556
2557   add_com ("tbreak", class_breakpoint, tbreak_command,
2558            "Set a temporary breakpoint.  Args like \"break\" command.\n\
2559 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2560 so it will be disabled when hit.  Equivalent to \"break\" followed\n\
2561 by using \"enable once\" on the breakpoint number.");
2562
2563   add_prefix_cmd ("enable", class_breakpoint, enable_command,
2564                   "Enable some breakpoints.\n\
2565 Give breakpoint numbers (separated by spaces) as arguments.\n\
2566 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2567 This is used to cancel the effect of the \"disable\" command.\n\
2568 With a subcommand you can enable temporarily.",
2569                   &enablelist, "enable ", 1, &cmdlist);
2570
2571   add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
2572                   "Enable some breakpoints.\n\
2573 Give breakpoint numbers (separated by spaces) as arguments.\n\
2574 This is used to cancel the effect of the \"disable\" command.\n\
2575 May be abbreviated to simply \"enable\".\n",
2576                   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
2577
2578   add_cmd ("once", no_class, enable_once_command,
2579            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
2580 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2581 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2582            &enablebreaklist);
2583
2584   add_cmd ("delete", no_class, enable_delete_command,
2585            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
2586 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2587            &enablebreaklist);
2588
2589   add_cmd ("delete", no_class, enable_delete_command,
2590            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
2591 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2592            &enablelist);
2593
2594   add_cmd ("once", no_class, enable_once_command,
2595            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
2596 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2597 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2598            &enablelist);
2599
2600   add_prefix_cmd ("disable", class_breakpoint, disable_command,
2601            "Disable some breakpoints.\n\
2602 Arguments are breakpoint numbers with spaces in between.\n\
2603 To disable all breakpoints, give no argument.\n\
2604 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
2605                   &disablelist, "disable ", 1, &cmdlist);
2606   add_com_alias ("dis", "disable", class_breakpoint, 1);
2607   add_com_alias ("disa", "disable", class_breakpoint, 1);
2608
2609   add_cmd ("breakpoints", class_alias, disable_command,
2610            "Disable some breakpoints.\n\
2611 Arguments are breakpoint numbers with spaces in between.\n\
2612 To disable all breakpoints, give no argument.\n\
2613 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
2614 This command may be abbreviated \"disable\".",
2615            &disablelist);
2616
2617   add_prefix_cmd ("delete", class_breakpoint, delete_command,
2618            "Delete some breakpoints or auto-display expressions.\n\
2619 Arguments are breakpoint numbers with spaces in between.\n\
2620 To delete all breakpoints, give no argument.\n\
2621 \n\
2622 Also a prefix command for deletion of other GDB objects.\n\
2623 The \"unset\" command is also an alias for \"delete\".",
2624                   &deletelist, "delete ", 1, &cmdlist);
2625   add_com_alias ("d", "delete", class_breakpoint, 1);
2626
2627   add_cmd ("breakpoints", class_alias, delete_command,
2628            "Delete some breakpoints or auto-display expressions.\n\
2629 Arguments are breakpoint numbers with spaces in between.\n\
2630 To delete all breakpoints, give no argument.\n\
2631 This command may be abbreviated \"delete\".",
2632            &deletelist);
2633
2634   add_com ("clear", class_breakpoint, clear_command,
2635            "Clear breakpoint at specified line or function.\n\
2636 Argument may be line number, function name, or \"*\" and an address.\n\
2637 If line number is specified, all breakpoints in that line are cleared.\n\
2638 If function is specified, breakpoints at beginning of function are cleared.\n\
2639 If an address is specified, breakpoints at that address are cleared.\n\n\
2640 With no argument, clears all breakpoints in the line that the selected frame\n\
2641 is executing in.\n\
2642 \n\
2643 See also the \"delete\" command which clears breakpoints by number.");
2644
2645   add_com ("break", class_breakpoint, break_command,
2646            "Set breakpoint at specified line or function.\n\
2647 Argument may be line number, function name, or \"*\" and an address.\n\
2648 If line number is specified, break at start of code for that line.\n\
2649 If function is specified, break at start of code for that function.\n\
2650 If an address is specified, break at that exact address.\n\
2651 With no arg, uses current execution address of selected stack frame.\n\
2652 This is useful for breaking on return to a stack frame.\n\
2653 \n\
2654 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2655 \n\
2656 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2657   add_com_alias ("b", "break", class_run, 1);
2658   add_com_alias ("br", "break", class_run, 1);
2659   add_com_alias ("bre", "break", class_run, 1);
2660   add_com_alias ("brea", "break", class_run, 1);
2661
2662   add_info ("breakpoints", breakpoints_info,
2663             "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
2664 The \"Type\" column indicates one of:\n\
2665 \tbreakpoint     - normal breakpoint\n\
2666 \twatchpoint     - watchpoint\n\
2667 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2668 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
2669 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
2670 address and file/line number respectively.\n\n\
2671 Convenience variable \"$_\" and default examine address for \"x\"\n\
2672 are set to the address of the last breakpoint listed.\n\n\
2673 Convenience variable \"$bpnum\" contains the number of the last\n\
2674 breakpoint set.");
2675
2676 #if MAINTENANCE_CMDS
2677
2678   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
2679             "Status of all breakpoints, or breakpoint number NUMBER.\n\
2680 The \"Type\" column indicates one of:\n\
2681 \tbreakpoint     - normal breakpoint\n\
2682 \twatchpoint     - watchpoint\n\
2683 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
2684 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
2685 \tuntil          - internal breakpoint used by the \"until\" command\n\
2686 \tfinish         - internal breakpoint used by the \"finish\" command\n\
2687 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2688 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
2689 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
2690 address and file/line number respectively.\n\n\
2691 Convenience variable \"$_\" and default examine address for \"x\"\n\
2692 are set to the address of the last breakpoint listed.\n\n\
2693 Convenience variable \"$bpnum\" contains the number of the last\n\
2694 breakpoint set.",
2695            &maintenanceinfolist);
2696
2697 #endif  /* MAINTENANCE_CMDS */
2698
2699   add_com ("catch", class_breakpoint, catch_command,
2700          "Set breakpoints to catch exceptions that are raised.\n\
2701 Argument may be a single exception to catch, multiple exceptions\n\
2702 to catch, or the default exception \"default\".  If no arguments\n\
2703 are given, breakpoints are set at all exception handlers catch clauses\n\
2704 within the current scope.\n\
2705 \n\
2706 A condition specified for the catch applies to all breakpoints set\n\
2707 with this command\n\
2708 \n\
2709 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2710
2711   add_com ("watch", class_breakpoint, watch_command,
2712            "Set a watchpoint for an expression.\n\
2713 A watchpoint stops execution of your program whenever the value of\n\
2714 an expression changes.");
2715
2716   add_info ("watchpoints", breakpoints_info,
2717             "Synonym for ``info breakpoints''.");
2718 }
2719
2720 #ifdef IBM6000_TARGET
2721 /* Where should this function go? It is used by AIX only. FIXME. */
2722
2723 /* Breakpoint address relocation used to be done in breakpoint_re_set(). That
2724    approach the following problem:
2725
2726      before running the program, if a file is list, then a breakpoint is
2727      set (just the line number), then if we switch into another file and run
2728      the program, just a line number as a breakpoint address was not
2729      descriptive enough and breakpoint was ending up in a different file's
2730      similar line. 
2731
2732   I don't think any other platform has this breakpoint relocation problem, so this
2733   is not an issue for other platforms. */
2734    
2735 void
2736 fixup_breakpoints (low, high, delta)
2737   CORE_ADDR low;
2738   CORE_ADDR high;
2739   CORE_ADDR delta;
2740 {
2741   struct breakpoint *b;
2742
2743   ALL_BREAKPOINTS (b)
2744     {
2745      if (b->address >= low && b->address <= high)
2746        b->address += delta;
2747     }
2748 }
2749 #endif