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