* breakpoint.h (struct bpstat): Remove momentary field.
[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 /* This is the normal print_it function for a bpstat.  In the future,
695    much of this logic could (should?) be moved to bpstat_stop_status,
696    by having it set different print_it functions.  */
697
698 static int
699 print_it_normal (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->breakpoint_at == NULL
705       || (bs->breakpoint_at->type != bp_breakpoint
706           && bs->breakpoint_at->type != bp_watchpoint))
707     return 0;
708
709   if (bs->breakpoint_at->type == bp_breakpoint)
710     {
711       /* I think the user probably only wants to see one breakpoint
712          number, not all of them.  */
713       printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
714       return 0;
715     }
716       
717   if (bs->old_val != NULL)
718     {
719       printf_filtered ("\nWatchpoint %d, ", bs->breakpoint_at->number);
720       print_expression (bs->breakpoint_at->exp, stdout);
721       printf_filtered ("\nOld value = ");
722       value_print (bs->old_val, stdout, 0, Val_pretty_default);
723       printf_filtered ("\nNew value = ");
724       value_print (bs->breakpoint_at->val, stdout, 0,
725                    Val_pretty_default);
726       printf_filtered ("\n");
727       value_free (bs->old_val);
728       bs->old_val = NULL;
729       return 0;
730     }
731   /* We can't deal with it.  Maybe another member of the bpstat chain can.  */
732   return -1;
733 }
734
735 /* Print a message indicating what happened.  Returns nonzero to
736    say that only the source line should be printed after this (zero
737    return means print the frame as well as the source line).  */
738 /* Currently we always return zero.  */
739 int
740 bpstat_print (bs)
741      bpstat bs;
742 {
743   int val;
744   
745   if (bs == NULL)
746     return 0;
747
748   val = (*bs->print_it) (bs);
749   if (val >= 0)
750     return val;
751   
752   /* Maybe another breakpoint in the chain caused us to stop.
753      (Currently all watchpoints go on the bpstat whether hit or
754      not.  That probably could (should) be changed, provided care is taken
755      with respect to bpstat_explains_signal).  */
756   if (bs->next)
757     return bpstat_print (bs->next);
758
759   /* We reached the end of the chain without printing anything.  */
760   return 0;
761 }
762
763 /* Evaluate the expression EXP and return 1 if value is zero.
764    This is used inside a catch_errors to evaluate the breakpoint condition. 
765    The argument is a "struct expression *" that has been cast to char * to 
766    make it pass through catch_errors.  */
767
768 static int
769 breakpoint_cond_eval (exp)
770      char *exp;
771 {
772   return !value_true (evaluate_expression ((struct expression *)exp));
773 }
774
775 /* Allocate a new bpstat and chain it to the current one.  */
776
777 static bpstat
778 bpstat_alloc (b, cbs)
779      register struct breakpoint *b;
780      bpstat cbs;                        /* Current "bs" value */
781 {
782   bpstat bs;
783
784   bs = (bpstat) xmalloc (sizeof (*bs));
785   cbs->next = bs;
786   bs->breakpoint_at = b;
787   /* If the condition is false, etc., don't do the commands.  */
788   bs->commands = NULL;
789   bs->old_val = NULL;
790   bs->print_it = print_it_normal;
791   return bs;
792 }
793
794 /* Possible return values for watchpoint_check (this can't be an enum
795    because of check_errors).  */
796 /* The watchpoint has been disabled.  */
797 #define WP_DISABLED 1
798 /* The value has changed.  */
799 #define WP_VALUE_CHANGED 2
800 /* The value has not changed.  */
801 #define WP_VALUE_NOT_CHANGED 3
802
803 /* Check watchpoint condition.  */
804 static int
805 watchpoint_check (p)
806      PTR p;
807 {
808   bpstat bs = (bpstat) p;
809
810   int within_current_scope;
811   if (bs->breakpoint_at->exp_valid_block != NULL)
812     within_current_scope =
813       contained_in (get_selected_block (), bs->breakpoint_at->exp_valid_block);
814   else
815     within_current_scope = 1;
816
817   if (within_current_scope)
818     {
819       /* We use value_{,free_to_}mark because it could be a
820          *long* time before we return to the command level and
821          call free_all_values.  */
822       /* But couldn't we just call free_all_values instead?  */
823
824       value mark = value_mark ();
825       value new_val = evaluate_expression (bs->breakpoint_at->exp);
826       if (!value_equal (bs->breakpoint_at->val, new_val))
827         {
828           release_value (new_val);
829           value_free_to_mark (mark);
830           bs->old_val = bs->breakpoint_at->val;
831           bs->breakpoint_at->val = new_val;
832           /* We will stop here */
833           return WP_VALUE_CHANGED;
834         }
835       else
836         {
837           /* Nothing changed, don't do anything.  */
838           value_free_to_mark (mark);
839           /* We won't stop here */
840           return WP_VALUE_NOT_CHANGED;
841         }
842     }
843   else
844     {
845       /* This seems like the only logical thing to do because
846          if we temporarily ignored the watchpoint, then when
847          we reenter the block in which it is valid it contains
848          garbage (in the case of a function, it may have two
849          garbage values, one before and one after the prologue).
850          So we can't even detect the first assignment to it and
851          watch after that (since the garbage may or may not equal
852          the first value assigned).  */
853       bs->breakpoint_at->enable = disabled;
854       printf_filtered ("\
855 Watchpoint %d disabled because the program has left the block in\n\
856 which its expression is valid.\n", bs->breakpoint_at->number);
857       return WP_DISABLED;
858     }
859 }
860
861 /* This is used when everything which needs to be printed has
862    already been printed.  But we still want to print the frame.  */
863 static int
864 print_it_done (bs)
865      bpstat bs;
866 {
867   return 0;
868 }
869
870 /* This is used when nothing should be printed for this bpstat entry.  */
871
872 static int
873 print_it_noop (bs)
874      bpstat bs;
875 {
876   return -1;
877 }
878
879 /* Determine whether we stopped at a breakpoint, etc, or whether we
880    don't understand this stop.  Result is a chain of bpstat's such that:
881
882         if we don't understand the stop, the result is a null pointer.
883
884         if we understand why we stopped, the result is not null, and
885         the first element of the chain contains summary "stop" and
886         "print" flags for the whole chain.
887
888         Each element of the chain refers to a particular breakpoint or
889         watchpoint at which we have stopped.  (We may have stopped for
890         several reasons concurrently.)
891
892         Each element of the chain has valid next, breakpoint_at,
893         commands, FIXME??? fields.
894
895  */
896
897         
898 bpstat
899 bpstat_stop_status (pc, frame_address)
900      CORE_ADDR *pc;
901      FRAME_ADDR frame_address;
902 {
903   register struct breakpoint *b;
904   CORE_ADDR bp_addr;
905 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
906   /* True if we've hit a breakpoint (as opposed to a watchpoint).  */
907   int real_breakpoint = 0;
908 #endif
909   /* Root of the chain of bpstat's */
910   struct bpstat root_bs[1];
911   /* Pointer to the last thing in the chain currently.  */
912   bpstat bs = root_bs;
913
914   /* Get the address where the breakpoint would have been.  */
915   bp_addr = *pc - DECR_PC_AFTER_BREAK;
916
917   ALL_BREAKPOINTS (b)
918     {
919       if (b->enable == disabled)
920         continue;
921
922       if (b->type != bp_watchpoint && b->address != bp_addr)
923         continue;
924
925       /* Come here if it's a watchpoint, or if the break address matches */
926
927       bs = bpstat_alloc (b, bs);        /* Alloc a bpstat to explain stop */
928
929       bs->stop = 1;
930       bs->print = 1;
931
932       if (b->type == bp_watchpoint)
933         {
934           static char message1[] =
935             "Error evaluating expression for watchpoint %d\n";
936           char message[sizeof (message1) + 30 /* slop */];
937           sprintf (message, message1, b->number);
938           switch (catch_errors (watchpoint_check, (char *) bs, message))
939             {
940             case WP_DISABLED:
941               /* We've already printed what needs to be printed.  */
942               bs->print_it = print_it_done;
943               /* Stop.  */
944               break;
945             case WP_VALUE_CHANGED:
946               /* Stop.  */
947               break;
948             case WP_VALUE_NOT_CHANGED:
949               /* Don't stop.  */
950               bs->print_it = print_it_noop;
951               bs->stop = 0;
952               continue;
953             default:
954               /* Can't happen.  */
955               /* FALLTHROUGH */
956             case 0:
957               /* Error from catch_errors.  */
958               b->enable = disabled;
959               printf_filtered ("Watchpoint %d disabled.\n", b->number);
960               /* We've already printed what needs to be printed.  */
961               bs->print_it = print_it_done;
962               /* Stop.  */
963               break;
964             }
965         }
966 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
967       else
968         real_breakpoint = 1;
969 #endif
970
971       if (b->frame && b->frame != frame_address)
972         bs->stop = 0;
973       else
974         {
975           int value_is_zero;
976
977           if (b->cond)
978             {
979               /* Need to select the frame, with all that implies
980                  so that the conditions will have the right context.  */
981               select_frame (get_current_frame (), 0);
982               value_is_zero
983                 = catch_errors (breakpoint_cond_eval, (char *)(b->cond),
984                                 "Error in testing breakpoint condition:\n");
985                                 /* FIXME-someday, should give breakpoint # */
986               free_all_values ();
987             }
988           if (b->cond && value_is_zero)
989             {
990               bs->stop = 0;
991             }
992           else if (b->ignore_count > 0)
993             {
994               b->ignore_count--;
995               bs->stop = 0;
996             }
997           else
998             {
999               /* We will stop here */
1000               if (b->disposition == disable)
1001                 b->enable = disabled;
1002               bs->commands = b->commands;
1003               if (b->silent)
1004                 bs->print = 0;
1005               if (bs->commands && STREQ ("silent", bs->commands->line))
1006                 {
1007                   bs->commands = bs->commands->next;
1008                   bs->print = 0;
1009                 }
1010             }
1011         }
1012       /* Print nothing for this entry if we dont stop or if we dont print.  */
1013       if (bs->stop == 0 || bs->print == 0)
1014         bs->print_it = print_it_noop;
1015     }
1016
1017   bs->next = NULL;              /* Terminate the chain */
1018   bs = root_bs->next;           /* Re-grab the head of the chain */
1019 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1020   if (bs)
1021     {
1022       if (real_breakpoint)
1023         {
1024           *pc = bp_addr;
1025 #if defined (SHIFT_INST_REGS)
1026           {
1027             CORE_ADDR pc = read_register (PC_REGNUM);
1028             CORE_ADDR npc = read_register (NPC_REGNUM);
1029             if (pc != npc)
1030               {
1031                 write_register (NNPC_REGNUM, npc);
1032                 write_register (NPC_REGNUM, pc);
1033               }
1034           }
1035 #else /* No SHIFT_INST_REGS.  */
1036           write_pc (bp_addr);
1037 #endif /* No SHIFT_INST_REGS.  */
1038         }
1039     }
1040 #endif /* DECR_PC_AFTER_BREAK != 0.  */
1041   return bs;
1042 }
1043 \f
1044 /* Tell what to do about this bpstat.  */
1045 enum bpstat_what
1046 bpstat_what (bs)
1047      bpstat bs;
1048 {
1049   /* Classify each bpstat as one of the following.  */
1050   enum class {
1051     /* There was a watchpoint, but we're not stopping.  */
1052     wp_nostop = 0,
1053
1054     /* There was a watchpoint, stop but don't print.  */
1055     wp_silent,
1056
1057     /* There was a watchpoint, stop and print.  */
1058     wp_noisy,
1059
1060     /* There was a breakpoint but we're not stopping.  */
1061     bp_nostop,
1062
1063     /* There was a breakpoint, stop but don't print.  */
1064     bp_silent,
1065
1066     /* There was a breakpoint, stop and print.  */
1067     bp_noisy,
1068
1069     /* We hit the longjmp breakpoint.  */
1070     long_jump,
1071
1072     /* We hit the longjmp_resume breakpoint.  */
1073     long_resume,
1074
1075     /* This is just used to count how many enums there are.  */
1076     class_last
1077     };
1078
1079   /* Here is the table which drives this routine.  So that we can
1080      format it pretty, we define some abbreviations for the
1081      enum bpstat_what codes.  */
1082 #define keep_c BPSTAT_WHAT_KEEP_CHECKING
1083 #define stop_s BPSTAT_WHAT_STOP_SILENT
1084 #define stop_n BPSTAT_WHAT_STOP_NOISY
1085 #define single BPSTAT_WHAT_SINGLE
1086 #define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1087 #define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1088 #define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1089 /* "Can't happen."  Might want to print an error message.
1090    abort() is not out of the question, but chances are GDB is just
1091    a bit confused, not unusable.  */
1092 #define err BPSTAT_WHAT_STOP_NOISY
1093
1094   /* Given an old action and a class, come up with a new action.  */
1095   static const enum bpstat_what
1096     table[(int)class_last][(int)BPSTAT_WHAT_LAST] =
1097       {
1098         /*                              old action */
1099         /*       keep_c  stop_s  stop_n  single  setlr   clrlr   clrlrs */
1100
1101 /*wp_nostop*/   {keep_c, stop_s, stop_n, single, setlr , clrlr , clrlrs},
1102 /*wp_silent*/   {stop_s, stop_s, stop_n, stop_s, stop_s, stop_s, stop_s},
1103 /*wp_noisy*/    {stop_n, stop_n, stop_n, stop_n, stop_n, stop_n, stop_n},
1104 /*bp_nostop*/   {single, stop_s, stop_n, single, setlr , clrlrs, clrlrs},
1105 /*bp_silent*/   {stop_s, stop_s, stop_n, stop_s, stop_s, stop_s, stop_s},
1106 /*bp_noisy*/    {stop_n, stop_n, stop_n, stop_n, stop_n, stop_n, stop_n},
1107 /*long_jump*/   {setlr , stop_s, stop_n, setlr , err   , err   , err   },
1108 /*long_resume*/ {clrlr , stop_s, stop_n, clrlrs, err   , err   , err   }
1109               };
1110 #undef keep_c
1111 #undef stop_s
1112 #undef stop_n
1113 #undef single
1114 #undef setlr
1115 #undef clrlr
1116 #undef clrlrs
1117 #undef err
1118   enum bpstat_what current_action = BPSTAT_WHAT_KEEP_CHECKING;
1119
1120   for (; bs != NULL; bs = bs->next)
1121     {
1122       enum class bs_class;
1123       if (bs->breakpoint_at == NULL)
1124         /* I suspect this can happen if it was a momentary breakpoint
1125            which has since been deleted.  */
1126         continue;
1127       switch (bs->breakpoint_at->type)
1128         {
1129         case bp_breakpoint:
1130         case bp_until:
1131         case bp_finish:
1132           if (bs->stop)
1133             {
1134               if (bs->print)
1135                 bs_class = bp_noisy;
1136               else
1137                 bs_class = bp_silent;
1138             }
1139           else
1140             bs_class = bp_nostop;
1141           break;
1142         case bp_watchpoint:
1143           if (bs->stop)
1144             {
1145               if (bs->print)
1146                 bs_class = wp_noisy;
1147               else
1148                 bs_class = wp_silent;
1149             }
1150           else
1151             bs_class = wp_nostop;
1152           break;
1153         case bp_longjmp:
1154           bs_class = long_jump;
1155           break;
1156         case bp_longjmp_resume:
1157           bs_class = long_resume;
1158           break;
1159         }
1160       current_action = table[(int)bs_class][(int)current_action];
1161     }
1162   return current_action;
1163 }
1164
1165 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1166    without hardware support).  This isn't related to a specific bpstat,
1167    just to things like whether watchpoints are set.  */
1168
1169 int 
1170 bpstat_should_step ()
1171 {
1172   struct breakpoint *b;
1173   ALL_BREAKPOINTS (b)
1174     if (b->enable == enabled && b->type == bp_watchpoint)
1175       return 1;
1176   return 0;
1177 }
1178 \f
1179 /* Print information on breakpoint number BNUM, or -1 if all.
1180    If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1181    is nonzero, process only watchpoints.  */
1182
1183 static void
1184 breakpoint_1 (bnum, allflag)
1185      int bnum;
1186      int allflag;
1187 {
1188   register struct breakpoint *b;
1189   register struct command_line *l;
1190   register struct symbol *sym;
1191   CORE_ADDR last_addr = (CORE_ADDR)-1;
1192   int found_a_breakpoint = 0;
1193   static char *bptypes[] = {"breakpoint", "until", "finish", "watchpoint",
1194                               "longjmp", "longjmp resume"};
1195   static char *bpdisps[] = {"del", "dis", "keep"};
1196   static char bpenables[] = "ny";
1197
1198   if (!breakpoint_chain)
1199     {
1200       printf_filtered ("No breakpoints or watchpoints.\n");
1201       return;
1202     }
1203   
1204   ALL_BREAKPOINTS (b)
1205     if (bnum == -1
1206         || bnum == b->number)
1207       {
1208 /*  We only print out user settable breakpoints unless the allflag is set. */
1209         if (!allflag
1210             && b->type != bp_breakpoint
1211             && b->type != bp_watchpoint)
1212           continue;
1213
1214         if (!found_a_breakpoint++)
1215           printf_filtered ("Num Type           Disp Enb %sWhat\n",
1216                            addressprint ? "Address    " : "");
1217
1218         printf_filtered ("%-3d %-14s %-4s %-3c ",
1219                          b->number,
1220                          bptypes[(int)b->type],
1221                          bpdisps[(int)b->disposition],
1222                          bpenables[(int)b->enable]);
1223         switch (b->type)
1224           {
1225           case bp_watchpoint:
1226             print_expression (b->exp, stdout);
1227             break;
1228           case bp_breakpoint:
1229           case bp_until:
1230           case bp_finish:
1231           case bp_longjmp:
1232           case bp_longjmp_resume:
1233             if (addressprint)
1234               printf_filtered ("%s ", local_hex_string_custom(b->address, "08"));
1235
1236             last_addr = b->address;
1237             if (b->symtab)
1238               {
1239                 sym = find_pc_function (b->address);
1240                 if (sym)
1241                   {
1242                     fputs_filtered ("in ", stdout);
1243                     fputs_filtered (SYMBOL_SOURCE_NAME (sym), stdout);
1244                     fputs_filtered (" at ", stdout);
1245                   }
1246                 fputs_filtered (b->symtab->filename, stdout);
1247                 printf_filtered (":%d", b->line_number);
1248               }
1249             else
1250               print_address_symbolic (b->address, stdout, demangle, " ");
1251           }
1252
1253         printf_filtered ("\n");
1254
1255         if (b->frame)
1256           printf_filtered ("\tstop only in stack frame at %s\n",
1257                            local_hex_string(b->frame));
1258         if (b->cond)
1259           {
1260             printf_filtered ("\tstop only if ");
1261             print_expression (b->cond, stdout);
1262             printf_filtered ("\n");
1263           }
1264         if (b->ignore_count)
1265           printf_filtered ("\tignore next %d hits\n", b->ignore_count);
1266         if ((l = b->commands))
1267           while (l)
1268             {
1269               fputs_filtered ("\t", stdout);
1270               fputs_filtered (l->line, stdout);
1271               fputs_filtered ("\n", stdout);
1272               l = l->next;
1273             }
1274       }
1275
1276   if (!found_a_breakpoint
1277       && bnum != -1)
1278     printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
1279   else
1280     /* Compare against (CORE_ADDR)-1 in case some compiler decides
1281        that a comparison of an unsigned with -1 is always false.  */
1282     if (last_addr != (CORE_ADDR)-1)
1283       set_next_address (last_addr);
1284 }
1285
1286 /* ARGSUSED */
1287 static void
1288 breakpoints_info (bnum_exp, from_tty)
1289      char *bnum_exp;
1290      int from_tty;
1291 {
1292   int bnum = -1;
1293
1294   if (bnum_exp)
1295     bnum = parse_and_eval_address (bnum_exp);
1296
1297   breakpoint_1 (bnum, 0);
1298 }
1299
1300 #if MAINTENANCE_CMDS
1301
1302 /* ARGSUSED */
1303 static void
1304 maintenance_info_breakpoints (bnum_exp, from_tty)
1305      char *bnum_exp;
1306      int from_tty;
1307 {
1308   int bnum = -1;
1309
1310   if (bnum_exp)
1311     bnum = parse_and_eval_address (bnum_exp);
1312
1313   breakpoint_1 (bnum, 1);
1314 }
1315
1316 #endif
1317
1318 /* Print a message describing any breakpoints set at PC.  */
1319
1320 static void
1321 describe_other_breakpoints (pc)
1322      register CORE_ADDR pc;
1323 {
1324   register int others = 0;
1325   register struct breakpoint *b;
1326
1327   ALL_BREAKPOINTS (b)
1328     if (b->address == pc)
1329       others++;
1330   if (others > 0)
1331     {
1332       printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
1333       ALL_BREAKPOINTS (b)
1334         if (b->address == pc)
1335           {
1336             others--;
1337             printf ("%d%s%s ",
1338                     b->number,
1339                     (b->enable == disabled) ? " (disabled)" : "",
1340                     (others > 1) ? "," : ((others == 1) ? " and" : ""));
1341           }
1342       printf ("also set at pc %s.\n", local_hex_string(pc));
1343     }
1344 }
1345 \f
1346 /* Set the default place to put a breakpoint
1347    for the `break' command with no arguments.  */
1348
1349 void
1350 set_default_breakpoint (valid, addr, symtab, line)
1351      int valid;
1352      CORE_ADDR addr;
1353      struct symtab *symtab;
1354      int line;
1355 {
1356   default_breakpoint_valid = valid;
1357   default_breakpoint_address = addr;
1358   default_breakpoint_symtab = symtab;
1359   default_breakpoint_line = line;
1360 }
1361
1362 /* Rescan breakpoints at address ADDRESS,
1363    marking the first one as "first" and any others as "duplicates".
1364    This is so that the bpt instruction is only inserted once.  */
1365
1366 static void
1367 check_duplicates (address)
1368      CORE_ADDR address;
1369 {
1370   register struct breakpoint *b;
1371   register int count = 0;
1372
1373   if (address == 0)             /* Watchpoints are uninteresting */
1374     return;
1375
1376   ALL_BREAKPOINTS (b)
1377     if (b->enable != disabled && b->address == address)
1378       {
1379         count++;
1380         b->duplicate = count > 1;
1381       }
1382 }
1383
1384 /* Low level routine to set a breakpoint.
1385    Takes as args the three things that every breakpoint must have.
1386    Returns the breakpoint object so caller can set other things.
1387    Does not set the breakpoint number!
1388    Does not print anything.
1389
1390    ==> This routine should not be called if there is a chance of later
1391    error(); otherwise it leaves a bogus breakpoint on the chain.  Validate
1392    your arguments BEFORE calling this routine!  */
1393
1394 static struct breakpoint *
1395 set_raw_breakpoint (sal)
1396      struct symtab_and_line sal;
1397 {
1398   register struct breakpoint *b, *b1;
1399
1400   b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
1401   memset (b, 0, sizeof (*b));
1402   b->address = sal.pc;
1403   b->symtab = sal.symtab;
1404   b->line_number = sal.line;
1405   b->enable = enabled;
1406   b->next = 0;
1407   b->silent = 0;
1408   b->ignore_count = 0;
1409   b->commands = NULL;
1410   b->frame = 0;
1411
1412   /* Add this breakpoint to the end of the chain
1413      so that a list of breakpoints will come out in order
1414      of increasing numbers.  */
1415
1416   b1 = breakpoint_chain;
1417   if (b1 == 0)
1418     breakpoint_chain = b;
1419   else
1420     {
1421       while (b1->next)
1422         b1 = b1->next;
1423       b1->next = b;
1424     }
1425
1426   check_duplicates (sal.pc);
1427
1428   return b;
1429 }
1430
1431 static void
1432 create_longjmp_breakpoint(func_name)
1433      char *func_name;
1434 {
1435   struct symtab_and_line sal;
1436   struct breakpoint *b;
1437   static int internal_breakpoint_number = -1;
1438
1439   if (func_name != NULL)
1440     {
1441       struct minimal_symbol *m;
1442
1443       m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
1444       if (m)
1445         sal.pc = SYMBOL_VALUE_ADDRESS (m);
1446       else
1447         return;
1448     }
1449   else
1450     sal.pc = 0;
1451
1452   sal.symtab = NULL;
1453   sal.line = 0;
1454
1455   b = set_raw_breakpoint(sal);
1456   if (!b) return;
1457
1458   b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
1459   b->disposition = donttouch;
1460   b->enable = disabled;
1461   b->silent = 1;
1462   if (func_name)
1463     b->addr_string = strsave(func_name);
1464   b->number = internal_breakpoint_number--;
1465 }
1466
1467 /* Call this routine when stepping and nexting to enable a breakpoint if we do
1468    a longjmp().  When we hit that breakpoint, call
1469    set_longjmp_resume_breakpoint() to figure out where we are going. */
1470
1471 void
1472 enable_longjmp_breakpoint()
1473 {
1474   register struct breakpoint *b;
1475
1476   ALL_BREAKPOINTS (b)
1477     if (b->type == bp_longjmp)
1478       {
1479         b->enable = enabled;
1480         check_duplicates (b->address);
1481       }
1482 }
1483
1484 void
1485 disable_longjmp_breakpoint()
1486 {
1487   register struct breakpoint *b;
1488
1489   ALL_BREAKPOINTS (b)
1490     if (   b->type == bp_longjmp
1491         || b->type == bp_longjmp_resume)
1492       {
1493         b->enable = disabled;
1494         check_duplicates (b->address);
1495       }
1496 }
1497
1498 /* Call this after hitting the longjmp() breakpoint.  Use this to set a new
1499    breakpoint at the target of the jmp_buf.
1500
1501    FIXME - This ought to be done by setting a temporary breakpoint that gets
1502    deleted automatically...
1503 */
1504
1505 void
1506 set_longjmp_resume_breakpoint(pc, frame)
1507      CORE_ADDR pc;
1508      FRAME frame;
1509 {
1510   register struct breakpoint *b;
1511
1512   ALL_BREAKPOINTS (b)
1513     if (b->type == bp_longjmp_resume)
1514       {
1515         b->address = pc;
1516         b->enable = enabled;
1517         if (frame != NULL)
1518           b->frame = FRAME_FP(frame);
1519         else
1520           b->frame = 0;
1521         check_duplicates (b->address);
1522         return;
1523       }
1524 }
1525
1526 /* Set a breakpoint that will evaporate an end of command
1527    at address specified by SAL.
1528    Restrict it to frame FRAME if FRAME is nonzero.  */
1529
1530 struct breakpoint *
1531 set_momentary_breakpoint (sal, frame, type)
1532      struct symtab_and_line sal;
1533      FRAME frame;
1534      enum bptype type;
1535 {
1536   register struct breakpoint *b;
1537   b = set_raw_breakpoint (sal);
1538   b->type = type;
1539   b->enable = enabled;
1540   b->disposition = donttouch;
1541   b->frame = (frame ? FRAME_FP (frame) : 0);
1542   return b;
1543 }
1544
1545 #if 0
1546 void
1547 clear_momentary_breakpoints ()
1548 {
1549   register struct breakpoint *b;
1550   ALL_BREAKPOINTS (b)
1551     if (b->disposition == delete)
1552       {
1553         delete_breakpoint (b);
1554         break;
1555       }
1556 }
1557 #endif
1558 \f
1559 /* Tell the user we have just set a breakpoint B.  */
1560 static void
1561 mention (b)
1562      struct breakpoint *b;
1563 {
1564   switch (b->type)
1565     {
1566     case bp_watchpoint:
1567       printf_filtered ("Watchpoint %d: ", b->number);
1568       print_expression (b->exp, stdout);
1569       break;
1570     case bp_breakpoint:
1571       printf_filtered ("Breakpoint %d at %s", b->number,
1572                        local_hex_string(b->address));
1573       if (b->symtab)
1574         printf_filtered (": file %s, line %d.",
1575                          b->symtab->filename, b->line_number);
1576       break;
1577     case bp_until:
1578     case bp_finish:
1579     case bp_longjmp:
1580     case bp_longjmp_resume:
1581       break;
1582     }
1583   printf_filtered ("\n");
1584 }
1585
1586 #if 0
1587 /* Nobody calls this currently. */
1588 /* Set a breakpoint from a symtab and line.
1589    If TEMPFLAG is nonzero, it is a temporary breakpoint.
1590    ADDR_STRING is a malloc'd string holding the name of where we are
1591    setting the breakpoint.  This is used later to re-set it after the
1592    program is relinked and symbols are reloaded.
1593    Print the same confirmation messages that the breakpoint command prints.  */
1594
1595 void
1596 set_breakpoint (s, line, tempflag, addr_string)
1597      struct symtab *s;
1598      int line;
1599      int tempflag;
1600      char *addr_string;
1601 {
1602   register struct breakpoint *b;
1603   struct symtab_and_line sal;
1604   
1605   sal.symtab = s;
1606   sal.line = line;
1607   sal.pc = 0;
1608   resolve_sal_pc (&sal);                        /* Might error out */
1609   describe_other_breakpoints (sal.pc);
1610
1611   b = set_raw_breakpoint (sal);
1612   set_breakpoint_count (breakpoint_count + 1);
1613   b->number = breakpoint_count;
1614   b->type = bp_breakpoint;
1615   b->cond = 0;
1616   b->addr_string = addr_string;
1617   b->enable = enabled;
1618   b->disposition = tempflag ? delete : donttouch;
1619
1620   mention (b);
1621 }
1622 #endif /* 0 */
1623 \f
1624 /* Set a breakpoint according to ARG (function, linenum or *address)
1625    and make it temporary if TEMPFLAG is nonzero. */
1626
1627 static void
1628 break_command_1 (arg, tempflag, from_tty)
1629      char *arg;
1630      int tempflag, from_tty;
1631 {
1632   struct symtabs_and_lines sals;
1633   struct symtab_and_line sal;
1634   register struct expression *cond = 0;
1635   register struct breakpoint *b;
1636
1637   /* Pointers in arg to the start, and one past the end, of the condition.  */
1638   char *cond_start = NULL;
1639   char *cond_end;
1640   /* Pointers in arg to the start, and one past the end,
1641      of the address part.  */
1642   char *addr_start = NULL;
1643   char *addr_end;
1644   
1645   int i;
1646
1647   sals.sals = NULL;
1648   sals.nelts = 0;
1649
1650   sal.line = sal.pc = sal.end = 0;
1651   sal.symtab = 0;
1652
1653   /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
1654
1655   if (!arg || (arg[0] == 'i' && arg[1] == 'f' 
1656                && (arg[2] == ' ' || arg[2] == '\t')))
1657     {
1658       if (default_breakpoint_valid)
1659         {
1660           sals.sals = (struct symtab_and_line *) 
1661             xmalloc (sizeof (struct symtab_and_line));
1662           sal.pc = default_breakpoint_address;
1663           sal.line = default_breakpoint_line;
1664           sal.symtab = default_breakpoint_symtab;
1665           sals.sals[0] = sal;
1666           sals.nelts = 1;
1667         }
1668       else
1669         error ("No default breakpoint address now.");
1670     }
1671   else
1672     {
1673       addr_start = arg;
1674
1675       /* Force almost all breakpoints to be in terms of the
1676          current_source_symtab (which is decode_line_1's default).  This
1677          should produce the results we want almost all of the time while
1678          leaving default_breakpoint_* alone.  */
1679       if (default_breakpoint_valid
1680           && (!current_source_symtab
1681               || (arg && (*arg == '+' || *arg == '-'))))
1682         sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1683                               default_breakpoint_line);
1684       else
1685         sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1686
1687       addr_end = arg;
1688     }
1689   
1690   if (! sals.nelts) 
1691     return;
1692
1693   /* Resolve all line numbers to PC's, and verify that conditions
1694      can be parsed, before setting any breakpoints.  */
1695   for (i = 0; i < sals.nelts; i++)
1696     {
1697       resolve_sal_pc (&sals.sals[i]);
1698       
1699       while (arg && *arg)
1700         {
1701           if (arg[0] == 'i' && arg[1] == 'f'
1702               && (arg[2] == ' ' || arg[2] == '\t'))
1703             {
1704               arg += 2;
1705               cond_start = arg;
1706               cond = parse_exp_1 (&arg, block_for_pc (sals.sals[i].pc), 0);
1707               cond_end = arg;
1708             }
1709           else
1710             error ("Junk at end of arguments.");
1711         }
1712     }
1713
1714   /* Now set all the breakpoints.  */
1715   for (i = 0; i < sals.nelts; i++)
1716     {
1717       sal = sals.sals[i];
1718
1719       if (from_tty)
1720         describe_other_breakpoints (sal.pc);
1721
1722       b = set_raw_breakpoint (sal);
1723       set_breakpoint_count (breakpoint_count + 1);
1724       b->number = breakpoint_count;
1725       b->type = bp_breakpoint;
1726       b->cond = cond;
1727
1728       /* FIXME: We should add the filename if this is a static function
1729          and probably if it is a line number (the line numbers could
1730          have changed when we re-read symbols; possibly better to disable
1731          the breakpoint in that case).  */
1732       if (addr_start)
1733         b->addr_string = savestring (addr_start, addr_end - addr_start);
1734       if (cond_start)
1735         b->cond_string = savestring (cond_start, cond_end - cond_start);
1736                                      
1737       b->enable = enabled;
1738       b->disposition = tempflag ? delete : donttouch;
1739
1740       mention (b);
1741     }
1742
1743   if (sals.nelts > 1)
1744     {
1745       printf ("Multiple breakpoints were set.\n");
1746       printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
1747     }
1748   free ((PTR)sals.sals);
1749 }
1750
1751 /* Helper function for break_command_1 and disassemble_command.  */
1752
1753 void
1754 resolve_sal_pc (sal)
1755      struct symtab_and_line *sal;
1756 {
1757   CORE_ADDR pc;
1758
1759   if (sal->pc == 0 && sal->symtab != 0)
1760     {
1761       pc = find_line_pc (sal->symtab, sal->line);
1762       if (pc == 0)
1763         error ("No line %d in file \"%s\".",
1764                sal->line, sal->symtab->filename);
1765       sal->pc = pc;
1766     }
1767 }
1768
1769 void
1770 break_command (arg, from_tty)
1771      char *arg;
1772      int from_tty;
1773 {
1774   break_command_1 (arg, 0, from_tty);
1775 }
1776
1777 static void
1778 tbreak_command (arg, from_tty)
1779      char *arg;
1780      int from_tty;
1781 {
1782   break_command_1 (arg, 1, from_tty);
1783 }
1784
1785 /* ARGSUSED */
1786 static void
1787 watch_command (arg, from_tty)
1788      char *arg;
1789      int from_tty;
1790 {
1791   struct breakpoint *b;
1792   struct symtab_and_line sal;
1793   struct expression *exp;
1794   struct block *exp_valid_block;
1795   struct value *val;
1796
1797   sal.pc = 0;
1798   sal.symtab = NULL;
1799   sal.line = 0;
1800   
1801   /* Parse arguments.  */
1802   innermost_block = NULL;
1803   exp = parse_expression (arg);
1804   exp_valid_block = innermost_block;
1805   val = evaluate_expression (exp);
1806   release_value (val);
1807   if (VALUE_LAZY (val))
1808     value_fetch_lazy (val);
1809
1810   /* Now set up the breakpoint.  */
1811   b = set_raw_breakpoint (sal);
1812   set_breakpoint_count (breakpoint_count + 1);
1813   b->number = breakpoint_count;
1814   b->type = bp_watchpoint;
1815   b->disposition = donttouch;
1816   b->exp = exp;
1817   b->exp_valid_block = exp_valid_block;
1818   b->val = val;
1819   b->cond = 0;
1820   b->cond_string = NULL;
1821   b->exp_string = savestring (arg, strlen (arg));
1822   mention (b);
1823 }
1824 \f
1825 /*
1826  * Helper routine for the until_command routine in infcmd.c.  Here
1827  * because it uses the mechanisms of breakpoints.
1828  */
1829 /* ARGSUSED */
1830 void
1831 until_break_command (arg, from_tty)
1832      char *arg;
1833      int from_tty;
1834 {
1835   struct symtabs_and_lines sals;
1836   struct symtab_and_line sal;
1837   FRAME prev_frame = get_prev_frame (selected_frame);
1838   struct breakpoint *breakpoint;
1839   struct cleanup *old_chain;
1840
1841   clear_proceed_status ();
1842
1843   /* Set a breakpoint where the user wants it and at return from
1844      this function */
1845   
1846   if (default_breakpoint_valid)
1847     sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
1848                           default_breakpoint_line);
1849   else
1850     sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0);
1851   
1852   if (sals.nelts != 1)
1853     error ("Couldn't get information on specified line.");
1854   
1855   sal = sals.sals[0];
1856   free ((PTR)sals.sals);                /* malloc'd, so freed */
1857   
1858   if (*arg)
1859     error ("Junk at end of arguments.");
1860   
1861   resolve_sal_pc (&sal);
1862   
1863   breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
1864   
1865   old_chain = make_cleanup(delete_breakpoint, breakpoint);
1866
1867   /* Keep within the current frame */
1868   
1869   if (prev_frame)
1870     {
1871       struct frame_info *fi;
1872       
1873       fi = get_frame_info (prev_frame);
1874       sal = find_pc_line (fi->pc, 0);
1875       sal.pc = fi->pc;
1876       breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
1877       make_cleanup(delete_breakpoint, breakpoint);
1878     }
1879   
1880   proceed (-1, -1, 0);
1881   do_cleanups(old_chain);
1882 }
1883 \f
1884 #if 0
1885 /* These aren't used; I don't konw what they were for.  */
1886 /* Set a breakpoint at the catch clause for NAME.  */
1887 static int
1888 catch_breakpoint (name)
1889      char *name;
1890 {
1891 }
1892
1893 static int
1894 disable_catch_breakpoint ()
1895 {
1896 }
1897
1898 static int
1899 delete_catch_breakpoint ()
1900 {
1901 }
1902
1903 static int
1904 enable_catch_breakpoint ()
1905 {
1906 }
1907 #endif /* 0 */
1908
1909 struct sal_chain
1910 {
1911   struct sal_chain *next;
1912   struct symtab_and_line sal;
1913 };
1914
1915 #if 0
1916 /* This isn't used; I don't know what it was for.  */
1917 /* For each catch clause identified in ARGS, run FUNCTION
1918    with that clause as an argument.  */
1919 static struct symtabs_and_lines
1920 map_catch_names (args, function)
1921      char *args;
1922      int (*function)();
1923 {
1924   register char *p = args;
1925   register char *p1;
1926   struct symtabs_and_lines sals;
1927 #if 0
1928   struct sal_chain *sal_chain = 0;
1929 #endif
1930
1931   if (p == 0)
1932     error_no_arg ("one or more catch names");
1933
1934   sals.nelts = 0;
1935   sals.sals = NULL;
1936
1937   while (*p)
1938     {
1939       p1 = p;
1940       /* Don't swallow conditional part.  */
1941       if (p1[0] == 'i' && p1[1] == 'f'
1942           && (p1[2] == ' ' || p1[2] == '\t'))
1943         break;
1944
1945       if (isalpha (*p1))
1946         {
1947           p1++;
1948           while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
1949             p1++;
1950         }
1951
1952       if (*p1 && *p1 != ' ' && *p1 != '\t')
1953         error ("Arguments must be catch names.");
1954
1955       *p1 = 0;
1956 #if 0
1957       if (function (p))
1958         {
1959           struct sal_chain *next
1960             = (struct sal_chain *)alloca (sizeof (struct sal_chain));
1961           next->next = sal_chain;
1962           next->sal = get_catch_sal (p);
1963           sal_chain = next;
1964           goto win;
1965         }
1966 #endif
1967       printf ("No catch clause for exception %s.\n", p);
1968 #if 0
1969     win:
1970 #endif
1971       p = p1;
1972       while (*p == ' ' || *p == '\t') p++;
1973     }
1974 }
1975 #endif /* 0 */
1976
1977 /* This shares a lot of code with `print_frame_label_vars' from stack.c.  */
1978
1979 static struct symtabs_and_lines
1980 get_catch_sals (this_level_only)
1981      int this_level_only;
1982 {
1983   register struct blockvector *bl;
1984   register struct block *block;
1985   int index, have_default = 0;
1986   struct frame_info *fi;
1987   CORE_ADDR pc;
1988   struct symtabs_and_lines sals;
1989   struct sal_chain *sal_chain = 0;
1990   char *blocks_searched;
1991
1992   /* Not sure whether an error message is always the correct response,
1993      but it's better than a core dump.  */
1994   if (selected_frame == NULL)
1995     error ("No selected frame.");
1996   block = get_frame_block (selected_frame);
1997   fi = get_frame_info (selected_frame);
1998   pc = fi->pc;
1999
2000   sals.nelts = 0;
2001   sals.sals = NULL;
2002
2003   if (block == 0)
2004     error ("No symbol table info available.\n");
2005
2006   bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
2007   blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
2008   memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
2009
2010   while (block != 0)
2011     {
2012       CORE_ADDR end = BLOCK_END (block) - 4;
2013       int last_index;
2014
2015       if (bl != blockvector_for_pc (end, &index))
2016         error ("blockvector blotch");
2017       if (BLOCKVECTOR_BLOCK (bl, index) != block)
2018         error ("blockvector botch");
2019       last_index = BLOCKVECTOR_NBLOCKS (bl);
2020       index += 1;
2021
2022       /* Don't print out blocks that have gone by.  */
2023       while (index < last_index
2024              && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
2025         index++;
2026
2027       while (index < last_index
2028              && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
2029         {
2030           if (blocks_searched[index] == 0)
2031             {
2032               struct block *b = BLOCKVECTOR_BLOCK (bl, index);
2033               int nsyms;
2034               register int i;
2035               register struct symbol *sym;
2036
2037               nsyms = BLOCK_NSYMS (b);
2038
2039               for (i = 0; i < nsyms; i++)
2040                 {
2041                   sym = BLOCK_SYM (b, i);
2042                   if (STREQ (SYMBOL_NAME (sym), "default"))
2043                     {
2044                       if (have_default)
2045                         continue;
2046                       have_default = 1;
2047                     }
2048                   if (SYMBOL_CLASS (sym) == LOC_LABEL)
2049                     {
2050                       struct sal_chain *next = (struct sal_chain *)
2051                         alloca (sizeof (struct sal_chain));
2052                       next->next = sal_chain;
2053                       next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2054                       sal_chain = next;
2055                     }
2056                 }
2057               blocks_searched[index] = 1;
2058             }
2059           index++;
2060         }
2061       if (have_default)
2062         break;
2063       if (sal_chain && this_level_only)
2064         break;
2065
2066       /* After handling the function's top-level block, stop.
2067          Don't continue to its superblock, the block of
2068          per-file symbols.  */
2069       if (BLOCK_FUNCTION (block))
2070         break;
2071       block = BLOCK_SUPERBLOCK (block);
2072     }
2073
2074   if (sal_chain)
2075     {
2076       struct sal_chain *tmp_chain;
2077
2078       /* Count the number of entries.  */
2079       for (index = 0, tmp_chain = sal_chain; tmp_chain;
2080            tmp_chain = tmp_chain->next)
2081         index++;
2082
2083       sals.nelts = index;
2084       sals.sals = (struct symtab_and_line *)
2085         xmalloc (index * sizeof (struct symtab_and_line));
2086       for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
2087         sals.sals[index] = sal_chain->sal;
2088     }
2089
2090   return sals;
2091 }
2092
2093 /* Commands to deal with catching exceptions.  */
2094
2095 static void
2096 catch_command_1 (arg, tempflag, from_tty)
2097      char *arg;
2098      int tempflag;
2099      int from_tty;
2100 {
2101   /* First, translate ARG into something we can deal with in terms
2102      of breakpoints.  */
2103
2104   struct symtabs_and_lines sals;
2105   struct symtab_and_line sal;
2106   register struct expression *cond = 0;
2107   register struct breakpoint *b;
2108   char *save_arg;
2109   int i;
2110
2111   sal.line = sal.pc = sal.end = 0;
2112   sal.symtab = 0;
2113
2114   /* If no arg given, or if first arg is 'if ', all active catch clauses
2115      are breakpointed. */
2116
2117   if (!arg || (arg[0] == 'i' && arg[1] == 'f' 
2118                && (arg[2] == ' ' || arg[2] == '\t')))
2119     {
2120       /* Grab all active catch clauses.  */
2121       sals = get_catch_sals (0);
2122     }
2123   else
2124     {
2125       /* Grab selected catch clauses.  */
2126       error ("catch NAME not implemeneted");
2127 #if 0
2128       /* This isn't used; I don't know what it was for.  */
2129       sals = map_catch_names (arg, catch_breakpoint);
2130 #endif
2131     }
2132
2133   if (! sals.nelts) 
2134     return;
2135
2136   save_arg = arg;
2137   for (i = 0; i < sals.nelts; i++)
2138     {
2139       resolve_sal_pc (&sals.sals[i]);
2140       
2141       while (arg && *arg)
2142         {
2143           if (arg[0] == 'i' && arg[1] == 'f'
2144               && (arg[2] == ' ' || arg[2] == '\t'))
2145             cond = parse_exp_1 ((arg += 2, &arg), 
2146                                 block_for_pc (sals.sals[i].pc), 0);
2147           else
2148             error ("Junk at end of arguments.");
2149         }
2150       arg = save_arg;
2151     }
2152
2153   for (i = 0; i < sals.nelts; i++)
2154     {
2155       sal = sals.sals[i];
2156
2157       if (from_tty)
2158         describe_other_breakpoints (sal.pc);
2159
2160       b = set_raw_breakpoint (sal);
2161       set_breakpoint_count (breakpoint_count + 1);
2162       b->number = breakpoint_count;
2163       b->type = bp_breakpoint;
2164       b->cond = cond;
2165       b->enable = enabled;
2166       b->disposition = tempflag ? delete : donttouch;
2167
2168       printf ("Breakpoint %d at %s", b->number, local_hex_string(b->address));
2169       if (b->symtab)
2170         printf (": file %s, line %d.", b->symtab->filename, b->line_number);
2171       printf ("\n");
2172     }
2173
2174   if (sals.nelts > 1)
2175     {
2176       printf ("Multiple breakpoints were set.\n");
2177       printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2178     }
2179   free ((PTR)sals.sals);
2180 }
2181
2182 #if 0
2183 /* These aren't used; I don't know what they were for.  */
2184 /* Disable breakpoints on all catch clauses described in ARGS.  */
2185 static void
2186 disable_catch (args)
2187      char *args;
2188 {
2189   /* Map the disable command to catch clauses described in ARGS.  */
2190 }
2191
2192 /* Enable breakpoints on all catch clauses described in ARGS.  */
2193 static void
2194 enable_catch (args)
2195      char *args;
2196 {
2197   /* Map the disable command to catch clauses described in ARGS.  */
2198 }
2199
2200 /* Delete breakpoints on all catch clauses in the active scope.  */
2201 static void
2202 delete_catch (args)
2203      char *args;
2204 {
2205   /* Map the delete command to catch clauses described in ARGS.  */
2206 }
2207 #endif /* 0 */
2208
2209 static void
2210 catch_command (arg, from_tty)
2211      char *arg;
2212      int from_tty;
2213 {
2214   catch_command_1 (arg, 0, from_tty);
2215 }
2216 \f
2217 static void
2218 clear_command (arg, from_tty)
2219      char *arg;
2220      int from_tty;
2221 {
2222   register struct breakpoint *b, *b1;
2223   struct symtabs_and_lines sals;
2224   struct symtab_and_line sal;
2225   register struct breakpoint *found;
2226   int i;
2227
2228   if (arg)
2229     {
2230       sals = decode_line_spec (arg, 1);
2231     }
2232   else
2233     {
2234       sals.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
2235       sal.line = default_breakpoint_line;
2236       sal.symtab = default_breakpoint_symtab;
2237       sal.pc = 0;
2238       if (sal.symtab == 0)
2239         error ("No source file specified.");
2240
2241       sals.sals[0] = sal;
2242       sals.nelts = 1;
2243     }
2244
2245   for (i = 0; i < sals.nelts; i++)
2246     {
2247       /* If exact pc given, clear bpts at that pc.
2248          But if sal.pc is zero, clear all bpts on specified line.  */
2249       sal = sals.sals[i];
2250       found = (struct breakpoint *) 0;
2251       while (breakpoint_chain
2252              && (sal.pc ? breakpoint_chain->address == sal.pc
2253                  : (breakpoint_chain->symtab == sal.symtab
2254                     && breakpoint_chain->line_number == sal.line)))
2255         {
2256           b1 = breakpoint_chain;
2257           breakpoint_chain = b1->next;
2258           b1->next = found;
2259           found = b1;
2260         }
2261
2262       ALL_BREAKPOINTS (b)
2263         while (b->next
2264                && b->next->type != bp_watchpoint
2265                && (sal.pc ? b->next->address == sal.pc
2266                    : (b->next->symtab == sal.symtab
2267                       && b->next->line_number == sal.line)))
2268           {
2269             b1 = b->next;
2270             b->next = b1->next;
2271             b1->next = found;
2272             found = b1;
2273           }
2274
2275       if (found == 0)
2276         {
2277           if (arg)
2278             error ("No breakpoint at %s.", arg);
2279           else
2280             error ("No breakpoint at this line.");
2281         }
2282
2283       if (found->next) from_tty = 1; /* Always report if deleted more than one */
2284       if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
2285       while (found)
2286         {
2287           if (from_tty) printf ("%d ", found->number);
2288           b1 = found->next;
2289           delete_breakpoint (found);
2290           found = b1;
2291         }
2292       if (from_tty) putchar ('\n');
2293     }
2294   free ((PTR)sals.sals);
2295 }
2296 \f
2297 /* Delete breakpoint in BS if they are `delete' breakpoints.
2298    This is called after any breakpoint is hit, or after errors.  */
2299
2300 void
2301 breakpoint_auto_delete (bs)
2302      bpstat bs;
2303 {
2304   for (; bs; bs = bs->next)
2305     if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete)
2306       delete_breakpoint (bs->breakpoint_at);
2307 }
2308
2309 /* Delete a breakpoint and clean up all traces of it in the data structures. */
2310
2311 void
2312 delete_breakpoint (bpt)
2313      struct breakpoint *bpt;
2314 {
2315   register struct breakpoint *b;
2316   register bpstat bs;
2317
2318   if (bpt->inserted)
2319       target_remove_breakpoint(bpt->address, bpt->shadow_contents);
2320
2321   if (breakpoint_chain == bpt)
2322     breakpoint_chain = bpt->next;
2323
2324   ALL_BREAKPOINTS (b)
2325     if (b->next == bpt)
2326       {
2327         b->next = bpt->next;
2328         break;
2329       }
2330
2331   check_duplicates (bpt->address);
2332
2333   free_command_lines (&bpt->commands);
2334   if (bpt->cond)
2335     free ((PTR)bpt->cond);
2336   if (bpt->cond_string != NULL)
2337     free ((PTR)bpt->cond_string);
2338   if (bpt->addr_string != NULL)
2339     free ((PTR)bpt->addr_string);
2340   if (bpt->exp_string != NULL)
2341     free ((PTR)bpt->exp_string);
2342
2343   if (xgdb_verbose && bpt->type == bp_breakpoint)
2344     printf ("breakpoint #%d deleted\n", bpt->number);
2345
2346   /* Be sure no bpstat's are pointing at it after it's been freed.  */
2347   /* FIXME, how can we find all bpstat's?  We just check stop_bpstat for now. */
2348   for (bs = stop_bpstat; bs; bs = bs->next)
2349     if (bs->breakpoint_at == bpt)
2350       bs->breakpoint_at = NULL;
2351   free ((PTR)bpt);
2352 }
2353
2354 static void
2355 delete_command (arg, from_tty)
2356      char *arg;
2357      int from_tty;
2358 {
2359
2360   if (arg == 0)
2361     {
2362       /* Ask user only if there are some breakpoints to delete.  */
2363       if (!from_tty
2364           || (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
2365         {
2366           /* No arg; clear all breakpoints.  */
2367           while (breakpoint_chain)
2368             delete_breakpoint (breakpoint_chain);
2369         }
2370     }
2371   else
2372     map_breakpoint_numbers (arg, delete_breakpoint);
2373 }
2374
2375 /* Reset a breakpoint given it's struct breakpoint * BINT.
2376    The value we return ends up being the return value from catch_errors.
2377    Unused in this case.  */
2378
2379 static int
2380 breakpoint_re_set_one (bint)
2381      char *bint;
2382 {
2383   struct breakpoint *b = (struct breakpoint *)bint;  /* get past catch_errs */
2384   int i;
2385   struct symtabs_and_lines sals;
2386   char *s;
2387   enum enable save_enable;
2388
2389   switch (b->type)
2390     {
2391     case bp_breakpoint:
2392       if (b->addr_string == NULL)
2393         {
2394           /* Anything without a string can't be re-set. */
2395           delete_breakpoint (b);
2396           return 0;
2397         }
2398       /* In case we have a problem, disable this breakpoint.  We'll restore
2399          its status if we succeed.  */
2400       save_enable = b->enable;
2401       b->enable = disabled;
2402
2403       s = b->addr_string;
2404       sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0);
2405       for (i = 0; i < sals.nelts; i++)
2406         {
2407           resolve_sal_pc (&sals.sals[i]);
2408           if (b->symtab != sals.sals[i].symtab
2409               || b->line_number != sals.sals[i].line
2410               || b->address != sals.sals[i].pc)
2411             {
2412               b->symtab = sals.sals[i].symtab;
2413               b->line_number = sals.sals[i].line;
2414               b->address = sals.sals[i].pc;
2415
2416               if (b->cond_string != NULL)
2417                 {
2418                   s = b->cond_string;
2419                   if (b->cond)
2420                     free ((PTR)b->cond);
2421                   b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
2422                 }
2423           
2424               check_duplicates (b->address);
2425
2426               mention (b);
2427             }
2428           b->enable = save_enable;      /* Restore it, this worked. */
2429         }
2430       free ((PTR)sals.sals);
2431       break;
2432
2433     case bp_watchpoint:
2434       innermost_block = NULL;
2435       /* The issue arises of what context to evaluate this in.  The same
2436          one as when it was set, but what does that mean when symbols have
2437          been re-read?  We could save the filename and functionname, but
2438          if the context is more local than that, the best we could do would
2439          be something like how many levels deep and which index at that
2440          particular level, but that's going to be less stable than filenames
2441          or functionnames.  */
2442       /* So for now, just use a global context.  */
2443       b->exp = parse_expression (b->exp_string);
2444       b->exp_valid_block = innermost_block;
2445       b->val = evaluate_expression (b->exp);
2446       release_value (b->val);
2447       if (VALUE_LAZY (b->val))
2448         value_fetch_lazy (b->val);
2449
2450       if (b->cond_string != NULL)
2451         {
2452           s = b->cond_string;
2453           b->cond = parse_exp_1 (&s, (struct block *)0, 0);
2454         }
2455       if (b->enable == enabled)
2456         mention (b);
2457       break;
2458
2459     default:
2460       printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
2461       /* fall through */
2462     case bp_until:
2463     case bp_finish:
2464     case bp_longjmp:
2465     case bp_longjmp_resume:
2466       delete_breakpoint (b);
2467       break;
2468     }
2469
2470   return 0;
2471 }
2472
2473 /* Re-set all breakpoints after symbols have been re-loaded.  */
2474 void
2475 breakpoint_re_set ()
2476 {
2477   struct breakpoint *b, *temp;
2478   static char message1[] = "Error in re-setting breakpoint %d:\n";
2479   char message[sizeof (message1) + 30 /* slop */];
2480   
2481   /* If we have no current source symtab, and we have any breakpoints,
2482      go through the work of making a source context.  */
2483   if (current_source_symtab == NULL && breakpoint_chain != 0)
2484     {
2485       select_source_symtab (NULL);
2486     }
2487
2488   ALL_BREAKPOINTS_SAFE (b, temp)
2489     {
2490       sprintf (message, message1, b->number);   /* Format possible error msg */
2491       catch_errors (breakpoint_re_set_one, (char *) b, message);
2492     }
2493
2494   create_longjmp_breakpoint("longjmp");
2495   create_longjmp_breakpoint("_longjmp");
2496   create_longjmp_breakpoint("siglongjmp");
2497   create_longjmp_breakpoint(NULL);
2498
2499 #if 0
2500   /* Took this out (temporaliy at least), since it produces an extra 
2501      blank line at startup. This messes up the gdbtests. -PB */
2502   /* Blank line to finish off all those mention() messages we just printed.  */
2503   printf_filtered ("\n");
2504 #endif
2505 }
2506 \f
2507 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
2508    If from_tty is nonzero, it prints a message to that effect,
2509    which ends with a period (no newline).  */
2510
2511 void
2512 set_ignore_count (bptnum, count, from_tty)
2513      int bptnum, count, from_tty;
2514 {
2515   register struct breakpoint *b;
2516
2517   if (count < 0)
2518     count = 0;
2519
2520   ALL_BREAKPOINTS (b)
2521     if (b->number == bptnum)
2522       {
2523         b->ignore_count = count;
2524         if (!from_tty)
2525           return;
2526         else if (count == 0)
2527           printf_filtered ("Will stop next time breakpoint %d is reached.",
2528                            bptnum);
2529         else if (count == 1)
2530           printf_filtered ("Will ignore next crossing of breakpoint %d.",
2531                            bptnum);
2532         else
2533           printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
2534                   count, bptnum);
2535         return;
2536       }
2537
2538   error ("No breakpoint number %d.", bptnum);
2539 }
2540
2541 /* Clear the ignore counts of all breakpoints.  */
2542 void
2543 breakpoint_clear_ignore_counts ()
2544 {
2545   struct breakpoint *b;
2546
2547   ALL_BREAKPOINTS (b)
2548     b->ignore_count = 0;
2549 }
2550
2551 /* Command to set ignore-count of breakpoint N to COUNT.  */
2552
2553 static void
2554 ignore_command (args, from_tty)
2555      char *args;
2556      int from_tty;
2557 {
2558   char *p = args;
2559   register int num;
2560
2561   if (p == 0)
2562     error_no_arg ("a breakpoint number");
2563   
2564   num = get_number (&p);
2565
2566   if (*p == 0)
2567     error ("Second argument (specified ignore-count) is missing.");
2568
2569   set_ignore_count (num,
2570                     longest_to_int (value_as_long (parse_and_eval (p))),
2571                     from_tty);
2572   printf_filtered ("\n");
2573 }
2574 \f
2575 /* Call FUNCTION on each of the breakpoints
2576    whose numbers are given in ARGS.  */
2577
2578 static void
2579 map_breakpoint_numbers (args, function)
2580      char *args;
2581      void (*function) PARAMS ((struct breakpoint *));
2582 {
2583   register char *p = args;
2584   char *p1;
2585   register int num;
2586   register struct breakpoint *b;
2587
2588   if (p == 0)
2589     error_no_arg ("one or more breakpoint numbers");
2590
2591   while (*p)
2592     {
2593       p1 = p;
2594       
2595       num = get_number (&p1);
2596
2597       ALL_BREAKPOINTS (b)
2598         if (b->number == num)
2599           {
2600             function (b);
2601             goto win;
2602           }
2603       printf ("No breakpoint number %d.\n", num);
2604     win:
2605       p = p1;
2606     }
2607 }
2608
2609 static void
2610 enable_breakpoint (bpt)
2611      struct breakpoint *bpt;
2612 {
2613   bpt->enable = enabled;
2614
2615   if (xgdb_verbose && bpt->type == bp_breakpoint)
2616     printf ("breakpoint #%d enabled\n", bpt->number);
2617
2618   check_duplicates (bpt->address);
2619   if (bpt->type == bp_watchpoint)
2620     {
2621       if (bpt->exp_valid_block != NULL
2622        && !contained_in (get_selected_block (), bpt->exp_valid_block))
2623         {
2624           printf_filtered ("\
2625 Cannot enable watchpoint %d because the block in which its expression\n\
2626 is valid is not currently in scope.\n", bpt->number);
2627           bpt->enable = disabled;
2628           return;
2629         }
2630
2631       value_free (bpt->val);
2632
2633       bpt->val = evaluate_expression (bpt->exp);
2634       release_value (bpt->val);
2635       if (VALUE_LAZY (bpt->val))
2636         value_fetch_lazy (bpt->val);
2637     }
2638 }
2639
2640 /* ARGSUSED */
2641 static void
2642 enable_command (args, from_tty)
2643      char *args;
2644      int from_tty;
2645 {
2646   struct breakpoint *bpt;
2647   if (args == 0)
2648     ALL_BREAKPOINTS (bpt)
2649       switch (bpt->type)
2650         {
2651         case bp_breakpoint:
2652         case bp_watchpoint:
2653           enable_breakpoint (bpt);
2654         default:
2655           continue;
2656         }
2657   else
2658     map_breakpoint_numbers (args, enable_breakpoint);
2659 }
2660
2661 static void
2662 disable_breakpoint (bpt)
2663      struct breakpoint *bpt;
2664 {
2665   bpt->enable = disabled;
2666
2667   if (xgdb_verbose && bpt->type == bp_breakpoint)
2668     printf_filtered ("breakpoint #%d disabled\n", bpt->number);
2669
2670   check_duplicates (bpt->address);
2671 }
2672
2673 /* ARGSUSED */
2674 static void
2675 disable_command (args, from_tty)
2676      char *args;
2677      int from_tty;
2678 {
2679   register struct breakpoint *bpt;
2680   if (args == 0)
2681     ALL_BREAKPOINTS (bpt)
2682       switch (bpt->type)
2683         {
2684         case bp_breakpoint:
2685         case bp_watchpoint:
2686           disable_breakpoint (bpt);
2687         default:
2688           continue;
2689         }
2690   else
2691     map_breakpoint_numbers (args, disable_breakpoint);
2692 }
2693
2694 static void
2695 enable_once_breakpoint (bpt)
2696      struct breakpoint *bpt;
2697 {
2698   bpt->enable = enabled;
2699   bpt->disposition = disable;
2700
2701   check_duplicates (bpt->address);
2702 }
2703
2704 /* ARGSUSED */
2705 static void
2706 enable_once_command (args, from_tty)
2707      char *args;
2708      int from_tty;
2709 {
2710   map_breakpoint_numbers (args, enable_once_breakpoint);
2711 }
2712
2713 static void
2714 enable_delete_breakpoint (bpt)
2715      struct breakpoint *bpt;
2716 {
2717   bpt->enable = enabled;
2718   bpt->disposition = delete;
2719
2720   check_duplicates (bpt->address);
2721 }
2722
2723 /* ARGSUSED */
2724 static void
2725 enable_delete_command (args, from_tty)
2726      char *args;
2727      int from_tty;
2728 {
2729   map_breakpoint_numbers (args, enable_delete_breakpoint);
2730 }
2731 \f
2732 /*
2733  * Use default_breakpoint_'s, or nothing if they aren't valid.
2734  */
2735 struct symtabs_and_lines
2736 decode_line_spec_1 (string, funfirstline)
2737      char *string;
2738      int funfirstline;
2739 {
2740   struct symtabs_and_lines sals;
2741   if (string == 0)
2742     error ("Empty line specification.");
2743   if (default_breakpoint_valid)
2744     sals = decode_line_1 (&string, funfirstline,
2745                           default_breakpoint_symtab, default_breakpoint_line);
2746   else
2747     sals = decode_line_1 (&string, funfirstline, (struct symtab *)NULL, 0);
2748   if (*string)
2749     error ("Junk at end of line specification: %s", string);
2750   return sals;
2751 }
2752 \f
2753 void
2754 _initialize_breakpoint ()
2755 {
2756   breakpoint_chain = 0;
2757   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
2758      before a breakpoint is set.  */
2759   breakpoint_count = 0;
2760
2761   add_com ("ignore", class_breakpoint, ignore_command,
2762            "Set ignore-count of breakpoint number N to COUNT.");
2763
2764   add_com ("commands", class_breakpoint, commands_command,
2765            "Set commands to be executed when a breakpoint is hit.\n\
2766 Give breakpoint number as argument after \"commands\".\n\
2767 With no argument, the targeted breakpoint is the last one set.\n\
2768 The commands themselves follow starting on the next line.\n\
2769 Type a line containing \"end\" to indicate the end of them.\n\
2770 Give \"silent\" as the first line to make the breakpoint silent;\n\
2771 then no output is printed when it is hit, except what the commands print.");
2772
2773   add_com ("condition", class_breakpoint, condition_command,
2774            "Specify breakpoint number N to break only if COND is true.\n\
2775 N is an integer; COND is an expression to be evaluated whenever\n\
2776 breakpoint N is reached.  ");
2777
2778   add_com ("tbreak", class_breakpoint, tbreak_command,
2779            "Set a temporary breakpoint.  Args like \"break\" command.\n\
2780 Like \"break\" except the breakpoint is only enabled temporarily,\n\
2781 so it will be disabled when hit.  Equivalent to \"break\" followed\n\
2782 by using \"enable once\" on the breakpoint number.");
2783
2784   add_prefix_cmd ("enable", class_breakpoint, enable_command,
2785                   "Enable some breakpoints.\n\
2786 Give breakpoint numbers (separated by spaces) as arguments.\n\
2787 With no subcommand, breakpoints are enabled until you command otherwise.\n\
2788 This is used to cancel the effect of the \"disable\" command.\n\
2789 With a subcommand you can enable temporarily.",
2790                   &enablelist, "enable ", 1, &cmdlist);
2791
2792   add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
2793                   "Enable some breakpoints.\n\
2794 Give breakpoint numbers (separated by spaces) as arguments.\n\
2795 This is used to cancel the effect of the \"disable\" command.\n\
2796 May be abbreviated to simply \"enable\".\n",
2797                   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
2798
2799   add_cmd ("once", no_class, enable_once_command,
2800            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
2801 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2802 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2803            &enablebreaklist);
2804
2805   add_cmd ("delete", no_class, enable_delete_command,
2806            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
2807 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2808            &enablebreaklist);
2809
2810   add_cmd ("delete", no_class, enable_delete_command,
2811            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
2812 If a breakpoint is hit while enabled in this fashion, it is deleted.",
2813            &enablelist);
2814
2815   add_cmd ("once", no_class, enable_once_command,
2816            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
2817 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
2818 See the \"tbreak\" command which sets a breakpoint and enables it once.",
2819            &enablelist);
2820
2821   add_prefix_cmd ("disable", class_breakpoint, disable_command,
2822            "Disable some breakpoints.\n\
2823 Arguments are breakpoint numbers with spaces in between.\n\
2824 To disable all breakpoints, give no argument.\n\
2825 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
2826                   &disablelist, "disable ", 1, &cmdlist);
2827   add_com_alias ("dis", "disable", class_breakpoint, 1);
2828   add_com_alias ("disa", "disable", class_breakpoint, 1);
2829
2830   add_cmd ("breakpoints", class_alias, disable_command,
2831            "Disable some breakpoints.\n\
2832 Arguments are breakpoint numbers with spaces in between.\n\
2833 To disable all breakpoints, give no argument.\n\
2834 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
2835 This command may be abbreviated \"disable\".",
2836            &disablelist);
2837
2838   add_prefix_cmd ("delete", class_breakpoint, delete_command,
2839            "Delete some breakpoints or auto-display expressions.\n\
2840 Arguments are breakpoint numbers with spaces in between.\n\
2841 To delete all breakpoints, give no argument.\n\
2842 \n\
2843 Also a prefix command for deletion of other GDB objects.\n\
2844 The \"unset\" command is also an alias for \"delete\".",
2845                   &deletelist, "delete ", 1, &cmdlist);
2846   add_com_alias ("d", "delete", class_breakpoint, 1);
2847
2848   add_cmd ("breakpoints", class_alias, delete_command,
2849            "Delete some breakpoints or auto-display expressions.\n\
2850 Arguments are breakpoint numbers with spaces in between.\n\
2851 To delete all breakpoints, give no argument.\n\
2852 This command may be abbreviated \"delete\".",
2853            &deletelist);
2854
2855   add_com ("clear", class_breakpoint, clear_command,
2856            "Clear breakpoint at specified line or function.\n\
2857 Argument may be line number, function name, or \"*\" and an address.\n\
2858 If line number is specified, all breakpoints in that line are cleared.\n\
2859 If function is specified, breakpoints at beginning of function are cleared.\n\
2860 If an address is specified, breakpoints at that address are cleared.\n\n\
2861 With no argument, clears all breakpoints in the line that the selected frame\n\
2862 is executing in.\n\
2863 \n\
2864 See also the \"delete\" command which clears breakpoints by number.");
2865
2866   add_com ("break", class_breakpoint, break_command,
2867            "Set breakpoint at specified line or function.\n\
2868 Argument may be line number, function name, or \"*\" and an address.\n\
2869 If line number is specified, break at start of code for that line.\n\
2870 If function is specified, break at start of code for that function.\n\
2871 If an address is specified, break at that exact address.\n\
2872 With no arg, uses current execution address of selected stack frame.\n\
2873 This is useful for breaking on return to a stack frame.\n\
2874 \n\
2875 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2876 \n\
2877 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2878   add_com_alias ("b", "break", class_run, 1);
2879   add_com_alias ("br", "break", class_run, 1);
2880   add_com_alias ("bre", "break", class_run, 1);
2881   add_com_alias ("brea", "break", class_run, 1);
2882
2883   add_info ("breakpoints", breakpoints_info,
2884             "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
2885 The \"Type\" column indicates one of:\n\
2886 \tbreakpoint     - normal breakpoint\n\
2887 \twatchpoint     - watchpoint\n\
2888 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2889 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
2890 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
2891 address and file/line number respectively.\n\n\
2892 Convenience variable \"$_\" and default examine address for \"x\"\n\
2893 are set to the address of the last breakpoint listed.\n\n\
2894 Convenience variable \"$bpnum\" contains the number of the last\n\
2895 breakpoint set.");
2896
2897 #if MAINTENANCE_CMDS
2898
2899   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
2900             "Status of all breakpoints, or breakpoint number NUMBER.\n\
2901 The \"Type\" column indicates one of:\n\
2902 \tbreakpoint     - normal breakpoint\n\
2903 \twatchpoint     - watchpoint\n\
2904 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
2905 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
2906 \tuntil          - internal breakpoint used by the \"until\" command\n\
2907 \tfinish         - internal breakpoint used by the \"finish\" command\n\
2908 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
2909 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
2910 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
2911 address and file/line number respectively.\n\n\
2912 Convenience variable \"$_\" and default examine address for \"x\"\n\
2913 are set to the address of the last breakpoint listed.\n\n\
2914 Convenience variable \"$bpnum\" contains the number of the last\n\
2915 breakpoint set.",
2916            &maintenanceinfolist);
2917
2918 #endif  /* MAINTENANCE_CMDS */
2919
2920   add_com ("catch", class_breakpoint, catch_command,
2921          "Set breakpoints to catch exceptions that are raised.\n\
2922 Argument may be a single exception to catch, multiple exceptions\n\
2923 to catch, or the default exception \"default\".  If no arguments\n\
2924 are given, breakpoints are set at all exception handlers catch clauses\n\
2925 within the current scope.\n\
2926 \n\
2927 A condition specified for the catch applies to all breakpoints set\n\
2928 with this command\n\
2929 \n\
2930 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
2931
2932   add_com ("watch", class_breakpoint, watch_command,
2933            "Set a watchpoint for an expression.\n\
2934 A watchpoint stops execution of your program whenever the value of\n\
2935 an expression changes.");
2936
2937   add_info ("watchpoints", breakpoints_info,
2938             "Synonym for ``info breakpoints''.");
2939 }
2940
2941 /* OK, when we call objfile_relocate, we need to relocate breakpoints
2942    too.  breakpoint_re_set is not a good choice--for example, if
2943    addr_string contains just a line number without a file name the
2944    breakpoint might get set in a different file.  In general, there is
2945    no need to go all the way back to the user's string (though this might
2946    work if some effort were made to canonicalize it), since symtabs and
2947    everything except addresses are still valid.
2948
2949    Probably the best way to solve this is to have each breakpoint save
2950    the objfile and the section number that was used to set it (if set
2951    by "*addr", probably it is best to use find_pc_line to get a symtab
2952    and use the objfile and block_line_section for that symtab).  Then
2953    objfile_relocate can call fixup_breakpoints with the objfile and
2954    the new_offsets, and it can relocate only the appropriate breakpoints.  */
2955
2956 #ifdef IBM6000_TARGET
2957 /* But for now, just kludge it based on the concept that before an
2958    objfile is relocated the breakpoint is below 0x10000000, and afterwards
2959    it is higher, so that way we only relocate each breakpoint once.  */
2960
2961 void
2962 fixup_breakpoints (low, high, delta)
2963   CORE_ADDR low;
2964   CORE_ADDR high;
2965   CORE_ADDR delta;
2966 {
2967   struct breakpoint *b;
2968
2969   ALL_BREAKPOINTS (b)
2970     {
2971      if (b->address >= low && b->address <= high)
2972        b->address += delta;
2973     }
2974 }
2975 #endif