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