* breakpoint.c (watchpoint_check): Don't bother restoring the
[platform/upstream/binutils.git] / gdb / breakpoint.c
1 /* Everything about breakpoints, for GDB.
2    Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994
3              Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
20
21 #include "defs.h"
22 #include <ctype.h>
23 #include "symtab.h"
24 #include "frame.h"
25 #include "breakpoint.h"
26 #include "gdbtypes.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 "thread.h"
35 #include "target.h"
36 #include "language.h"
37 #include <string.h>
38 #include "demangle.h"
39 #include "annotate.h"
40
41 /* local function prototypes */
42
43 static void
44 catch_command_1 PARAMS ((char *, int, int));
45
46 static void
47 enable_delete_command PARAMS ((char *, int));
48
49 static void
50 enable_delete_breakpoint PARAMS ((struct breakpoint *));
51
52 static void
53 enable_once_command PARAMS ((char *, int));
54
55 static void
56 enable_once_breakpoint PARAMS ((struct breakpoint *));
57
58 static void
59 disable_command PARAMS ((char *, int));
60
61 static void
62 disable_breakpoint PARAMS ((struct breakpoint *));
63
64 static void
65 enable_command PARAMS ((char *, int));
66
67 static void
68 enable_breakpoint PARAMS ((struct breakpoint *));
69
70 static void
71 map_breakpoint_numbers PARAMS ((char *, void (*)(struct breakpoint *)));
72
73 static void
74 ignore_command PARAMS ((char *, int));
75
76 static int
77 breakpoint_re_set_one PARAMS ((char *));
78
79 static void
80 delete_command PARAMS ((char *, int));
81
82 static void
83 clear_command PARAMS ((char *, int));
84
85 static void
86 catch_command PARAMS ((char *, int));
87
88 static struct symtabs_and_lines
89 get_catch_sals PARAMS ((int));
90
91 static void
92 watch_command PARAMS ((char *, int));
93
94 static int
95 can_use_hardware_watchpoint PARAMS ((struct value *));
96
97 static void
98 tbreak_command PARAMS ((char *, int));
99
100 static void
101 break_command_1 PARAMS ((char *, int, int));
102
103 static void
104 mention PARAMS ((struct breakpoint *));
105
106 static struct breakpoint *
107 set_raw_breakpoint PARAMS ((struct symtab_and_line));
108
109 static void
110 check_duplicates PARAMS ((CORE_ADDR));
111
112 static void
113 describe_other_breakpoints PARAMS ((CORE_ADDR));
114
115 static void
116 breakpoints_info PARAMS ((char *, int));
117
118 static void
119 breakpoint_1 PARAMS ((int, int));
120
121 static bpstat
122 bpstat_alloc PARAMS ((struct breakpoint *, bpstat));
123
124 static int
125 breakpoint_cond_eval PARAMS ((char *));
126
127 static void
128 cleanup_executing_breakpoints PARAMS ((int));
129
130 static void
131 commands_command PARAMS ((char *, int));
132
133 static void
134 condition_command PARAMS ((char *, int));
135
136 static int
137 get_number PARAMS ((char **));
138
139 static void
140 set_breakpoint_count PARAMS ((int));
141
142 static int
143 remove_breakpoint PARAMS ((struct breakpoint *));
144
145 extern int addressprint;                /* Print machine addresses? */
146
147 /* Are we executing breakpoint commands?  */
148 static int executing_breakpoint_commands;
149
150 /* Walk the following statement or block through all breakpoints.
151    ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
152    breakpoint.  */
153
154 #define ALL_BREAKPOINTS(b)  for (b = breakpoint_chain; b; b = b->next)
155
156 #define ALL_BREAKPOINTS_SAFE(b,tmp)     \
157         for (b = breakpoint_chain;      \
158              b? (tmp=b->next, 1): 0;    \
159              b = tmp)
160
161 /* By default no support for hardware watchpoints is assumed.  */
162 #ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT
163 #define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) 0
164 #define target_remove_watchpoint(ADDR,LEN,TYPE) -1
165 #define target_insert_watchpoint(ADDR,LEN,TYPE) -1
166 #endif
167
168 #ifndef target_insert_hw_breakpoint
169 #define target_remove_hw_breakpoint(ADDR,SHADOW) -1
170 #define target_insert_hw_breakpoint(ADDR,SHADOW) -1
171 #endif
172
173 #ifndef target_stopped_data_address
174 #define target_stopped_data_address() 0
175 #endif
176
177 /* True if breakpoint hit counts should be displayed in breakpoint info.  */
178
179 int show_breakpoint_hit_counts = 1;
180
181 /* Chain of all breakpoints defined.  */
182
183 static struct breakpoint *breakpoint_chain;
184
185 /* Number of last breakpoint made.  */
186
187 static int breakpoint_count;
188
189 /* Set breakpoint count to NUM.  */
190
191 static void
192 set_breakpoint_count (num)
193      int num;
194 {
195   breakpoint_count = num;
196   set_internalvar (lookup_internalvar ("bpnum"),
197                    value_from_longest (builtin_type_int, (LONGEST) num));
198 }
199
200 /* Used in run_command to zero the hit count when a new run starts. */
201
202 void
203 clear_breakpoint_hit_counts ()
204 {
205   struct breakpoint *b;
206
207   ALL_BREAKPOINTS (b)
208     b->hit_count = 0;
209 }
210
211 /* Default address, symtab and line to put a breakpoint at
212    for "break" command with no arg.
213    if default_breakpoint_valid is zero, the other three are
214    not valid, and "break" with no arg is an error.
215
216    This set by print_stack_frame, which calls set_default_breakpoint.  */
217
218 int default_breakpoint_valid;
219 CORE_ADDR default_breakpoint_address;
220 struct symtab *default_breakpoint_symtab;
221 int default_breakpoint_line;
222 \f
223 /* *PP is a string denoting a breakpoint.  Get the number of the breakpoint.
224    Advance *PP after the string and any trailing whitespace.
225
226    Currently the string can either be a number or "$" followed by the name
227    of a convenience variable.  Making it an expression wouldn't work well
228    for map_breakpoint_numbers (e.g. "4 + 5 + 6").  */
229 static int
230 get_number (pp)
231      char **pp;
232 {
233   int retval;
234   char *p = *pp;
235
236   if (p == NULL)
237     /* Empty line means refer to the last breakpoint.  */
238     return breakpoint_count;
239   else if (*p == '$')
240     {
241       /* Make a copy of the name, so we can null-terminate it
242          to pass to lookup_internalvar().  */
243       char *varname;
244       char *start = ++p;
245       value_ptr val;
246
247       while (isalnum (*p) || *p == '_')
248         p++;
249       varname = (char *) alloca (p - start + 1);
250       strncpy (varname, start, p - start);
251       varname[p - start] = '\0';
252       val = value_of_internalvar (lookup_internalvar (varname));
253       if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_INT)
254         error (
255 "Convenience variables used to specify breakpoints must have integer values."
256                );
257       retval = (int) value_as_long (val);
258     }
259   else
260     {
261       if (*p == '-')
262         ++p;
263       while (*p >= '0' && *p <= '9')
264         ++p;
265       if (p == *pp)
266         /* There is no number here.  (e.g. "cond a == b").  */
267         error_no_arg ("breakpoint number");
268       retval = atoi (*pp);
269     }
270   if (!(isspace (*p) || *p == '\0'))
271     error ("breakpoint number expected");
272   while (isspace (*p))
273     p++;
274   *pp = p;
275   return retval;
276 }
277 \f
278 /* condition N EXP -- set break condition of breakpoint N to EXP.  */
279
280 static void
281 condition_command (arg, from_tty)
282      char *arg;
283      int from_tty;
284 {
285   register struct breakpoint *b;
286   char *p;
287   register int bnum;
288
289   if (arg == 0)
290     error_no_arg ("breakpoint number");
291
292   p = arg;
293   bnum = get_number (&p);
294
295   ALL_BREAKPOINTS (b)
296     if (b->number == bnum)
297       {
298         if (b->cond)
299           {
300             free ((PTR)b->cond);
301             b->cond = 0;
302           }
303         if (b->cond_string != NULL)
304           free ((PTR)b->cond_string);
305
306         if (*p == 0)
307           {
308             b->cond = 0;
309             b->cond_string = NULL;
310             if (from_tty)
311               printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
312           }
313         else
314           {
315             arg = p;
316             /* I don't know if it matters whether this is the string the user
317                typed in or the decompiled expression.  */
318             b->cond_string = savestring (arg, strlen (arg));
319             b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
320             if (*arg)
321               error ("Junk at end of expression");
322           }
323         breakpoints_changed ();
324         return;
325       }
326
327   error ("No breakpoint number %d.", bnum);
328 }
329
330 /* ARGSUSED */
331 static void
332 commands_command (arg, from_tty)
333      char *arg;
334      int from_tty;
335 {
336   register struct breakpoint *b;
337   char *p;
338   register int bnum;
339   struct command_line *l;
340
341   /* If we allowed this, we would have problems with when to
342      free the storage, if we change the commands currently
343      being read from.  */
344
345   if (executing_breakpoint_commands)
346     error ("Can't use the \"commands\" command among a breakpoint's commands.");
347
348   p = arg;
349   bnum = get_number (&p);
350   if (p && *p)
351     error ("Unexpected extra arguments following breakpoint number.");
352       
353   ALL_BREAKPOINTS (b)
354     if (b->number == bnum)
355       {
356         if (from_tty && input_from_terminal_p ())
357           printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
358 End with a line saying just \"end\".\n", bnum);
359         l = read_command_lines ();
360         free_command_lines (&b->commands);
361         b->commands = l;
362         breakpoints_changed ();
363         return;
364       }
365   error ("No breakpoint number %d.", bnum);
366 }
367 \f
368 extern int memory_breakpoint_size; /* from mem-break.c */
369
370 /* Like target_read_memory() but if breakpoints are inserted, return
371    the shadow contents instead of the breakpoints themselves.
372
373    Read "memory data" from whatever target or inferior we have. 
374    Returns zero if successful, errno value if not.  EIO is used
375    for address out of bounds.  If breakpoints are inserted, returns
376    shadow contents, not the breakpoints themselves.  From breakpoint.c.  */
377
378 int
379 read_memory_nobpt (memaddr, myaddr, len)
380      CORE_ADDR memaddr;
381      char *myaddr;
382      unsigned len;
383 {
384   int status;
385   struct breakpoint *b;
386
387   if (memory_breakpoint_size < 0)
388     /* No breakpoints on this machine.  FIXME: This should be
389        dependent on the debugging target.  Probably want
390        target_insert_breakpoint to return a size, saying how many
391        bytes of the shadow contents are used, or perhaps have
392        something like target_xfer_shadow.  */
393     return target_read_memory (memaddr, myaddr, len);
394   
395   ALL_BREAKPOINTS (b)
396     {
397       if (b->type == bp_watchpoint
398           || b->type == bp_hardware_watchpoint
399           || b->type == bp_read_watchpoint
400           || b->type == bp_access_watchpoint
401           || !b->inserted)
402         continue;
403       else if (b->address + memory_breakpoint_size <= memaddr)
404         /* The breakpoint is entirely before the chunk of memory
405            we are reading.  */
406         continue;
407       else if (b->address >= memaddr + len)
408         /* The breakpoint is entirely after the chunk of memory we
409            are reading.  */
410         continue;
411       else
412         {
413           /* Copy the breakpoint from the shadow contents, and recurse
414              for the things before and after.  */
415           
416           /* Addresses and length of the part of the breakpoint that
417              we need to copy.  */
418           CORE_ADDR membpt = b->address;
419           unsigned int bptlen = memory_breakpoint_size;
420           /* Offset within shadow_contents.  */
421           int bptoffset = 0;
422           
423           if (membpt < memaddr)
424             {
425               /* Only copy the second part of the breakpoint.  */
426               bptlen -= memaddr - membpt;
427               bptoffset = memaddr - membpt;
428               membpt = memaddr;
429             }
430
431           if (membpt + bptlen > memaddr + len)
432             {
433               /* Only copy the first part of the breakpoint.  */
434               bptlen -= (membpt + bptlen) - (memaddr + len);
435             }
436
437           memcpy (myaddr + membpt - memaddr, 
438                   b->shadow_contents + bptoffset, bptlen);
439
440           if (membpt > memaddr)
441             {
442               /* Copy the section of memory before the breakpoint.  */
443               status = read_memory_nobpt (memaddr, myaddr, membpt - memaddr);
444               if (status != 0)
445                 return status;
446             }
447
448           if (membpt + bptlen < memaddr + len)
449             {
450               /* Copy the section of memory after the breakpoint.  */
451               status = read_memory_nobpt
452                 (membpt + bptlen,
453                  myaddr + membpt + bptlen - memaddr,
454                  memaddr + len - (membpt + bptlen));
455               if (status != 0)
456                 return status;
457             }
458           return 0;
459         }
460     }
461   /* Nothing overlaps.  Just call read_memory_noerr.  */
462   return target_read_memory (memaddr, myaddr, len);
463 }
464 \f
465 /* insert_breakpoints is used when starting or continuing the program.
466    remove_breakpoints is used when the program stops.
467    Both return zero if successful,
468    or an `errno' value if could not write the inferior.  */
469
470 int
471 insert_breakpoints ()
472 {
473   register struct breakpoint *b;
474   int val = 0;
475   int disabled_breaks = 0;
476
477   ALL_BREAKPOINTS (b)
478     if (b->type != bp_watchpoint
479         && b->type != bp_hardware_watchpoint
480         && b->type != bp_read_watchpoint
481         && b->type != bp_access_watchpoint
482         && b->enable != disabled
483         && ! b->inserted
484         && ! b->duplicate)
485       {
486         if (b->type == bp_hardware_breakpoint)
487           val = target_insert_hw_breakpoint(b->address, b->shadow_contents);
488         else
489           val = target_insert_breakpoint(b->address, b->shadow_contents);
490         if (val)
491           {
492             /* Can't set the breakpoint.  */
493 #if defined (DISABLE_UNSETTABLE_BREAK)
494             if (DISABLE_UNSETTABLE_BREAK (b->address))
495               {
496                 val = 0;
497                 b->enable = disabled;
498                 if (!disabled_breaks)
499                   {
500                     target_terminal_ours_for_output ();
501                     fprintf_unfiltered (gdb_stderr,
502                          "Cannot insert breakpoint %d:\n", b->number);
503                     printf_filtered ("Disabling shared library breakpoints:\n");
504                   }
505                 disabled_breaks = 1;
506                 printf_filtered ("%d ", b->number);
507               }
508             else
509 #endif
510               {
511                 target_terminal_ours_for_output ();
512                 fprintf_unfiltered (gdb_stderr, "Cannot insert breakpoint %d:\n", b->number);
513 #ifdef ONE_PROCESS_WRITETEXT
514                 fprintf_unfiltered (gdb_stderr,
515                   "The same program may be running in another process.\n");
516 #endif
517                 memory_error (val, b->address); /* which bombs us out */
518               }
519           }
520         else
521           b->inserted = 1;
522       }
523     else if ((b->type == bp_hardware_watchpoint ||
524               b->type == bp_read_watchpoint ||
525               b->type == bp_access_watchpoint)
526              && b->enable == enabled
527              && ! b->inserted
528              && ! b->duplicate)
529       {
530         struct frame_info *saved_frame;
531         int saved_level, within_current_scope;
532         value_ptr mark = value_mark ();
533         value_ptr v;
534
535         /* Save the current frame and level so we can restore it after
536            evaluating the watchpoint expression on its own frame.  */
537         saved_frame = selected_frame;
538         saved_level = selected_frame_level;
539
540         /* Determine if the watchpoint is within scope.  */
541         if (b->exp_valid_block == NULL)
542           within_current_scope = 1;
543         else
544           {
545             struct frame_info *fi =
546               find_frame_addr_in_frame_chain (b->watchpoint_frame);
547             within_current_scope = (fi != NULL);
548             if (within_current_scope)
549               select_frame (fi, -1);
550           }
551         
552         if (within_current_scope)
553           {
554             /* Evaluate the expression and cut the chain of values
555                produced off from the value chain.  */
556             v = evaluate_expression (b->exp);
557             value_release_to_mark (mark);
558             
559             b->val_chain = v;
560             b->inserted = 1;
561
562             /* Look at each value on the value chain.  */
563             for ( ; v; v=v->next)
564               {
565                 /* If it's a memory location, then we must watch it.  */
566                 if (v->lval == lval_memory)
567                   {
568                     int addr, len, type;
569                     
570                     addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
571                     len = TYPE_LENGTH (VALUE_TYPE (v));
572                     type = 0;
573                     if (b->type == bp_read_watchpoint)
574                       type = 1;
575                     else if (b->type == bp_access_watchpoint)
576                       type = 2;
577
578                     val = target_insert_watchpoint (addr, len, type);
579                     if (val == -1)
580                       {
581                         b->inserted = 0;
582                         break;
583                       }
584                     val = 0;
585                   }
586               }
587             /* Failure to insert a watchpoint on any memory value in the
588                value chain brings us here.  */
589             if (!b->inserted)
590               warning ("Hardware watchpoint %d: Could not insert watchpoint\n",
591                        b->number);
592           }
593         else
594           {
595             printf_filtered ("\
596 Hardware watchpoint %d deleted because the program has left the block in\n\
597 which its expression is valid.\n", b->number);
598             if (b->related_breakpoint)
599               delete_breakpoint (b->related_breakpoint);
600             delete_breakpoint (b);
601           }
602
603         /* Restore the frame and level.  */
604         select_frame (saved_frame, saved_level);
605       }
606   if (disabled_breaks)
607     printf_filtered ("\n");
608   return val;
609 }
610
611
612 int
613 remove_breakpoints ()
614 {
615   register struct breakpoint *b;
616   int val;
617
618   ALL_BREAKPOINTS (b)
619     {
620       if (b->inserted)
621         {
622           val = remove_breakpoint (b);
623           if (val != 0)
624             return val;
625         }
626     }
627   return 0;
628 }
629
630
631 static int
632 remove_breakpoint (b)
633      struct breakpoint *b;
634 {
635   int val;
636   
637   if (b->type != bp_watchpoint
638       && b->type != bp_hardware_watchpoint
639       && b->type != bp_read_watchpoint
640       && b->type != bp_access_watchpoint)
641     {
642       if (b->type == bp_hardware_breakpoint)
643         val = target_remove_hw_breakpoint(b->address, b->shadow_contents);
644       else
645         val = target_remove_breakpoint(b->address, b->shadow_contents);
646       if (val)
647         return val;
648       b->inserted = 0;
649     }
650   else if ((b->type == bp_hardware_watchpoint ||
651             b->type == bp_read_watchpoint ||
652             b->type == bp_access_watchpoint)
653            && b->enable == enabled
654            && ! b->duplicate)
655     {
656       value_ptr v, n;
657       
658       b->inserted = 0;
659       /* Walk down the saved value chain.  */
660       for (v = b->val_chain; v; v = v->next)
661         {
662           /* For each memory reference remove the watchpoint
663              at that address.  */
664           if (v->lval == lval_memory)
665             {
666               int addr, len;
667               
668               addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
669               len = TYPE_LENGTH (VALUE_TYPE (v));
670               val = target_remove_watchpoint (addr, len, b->type);
671               if (val == -1)
672                 b->inserted = 1;
673               val = 0;
674             }
675         }
676       /* Failure to remove any of the hardware watchpoints comes here.  */
677       if (b->inserted)
678         error ("Hardware watchpoint %d: Could not remove watchpoint\n",
679                b->number);
680       
681       /* Free the saved value chain.  We will construct a new one
682          the next time the watchpoint is inserted.  */
683       for (v = b->val_chain; v; v = n)
684         {
685           n = v->next;
686           value_free (v);
687         }
688       b->val_chain = NULL;
689     }
690   return 0;
691 }
692
693 /* Clear the "inserted" flag in all breakpoints.  */
694
695 void
696 mark_breakpoints_out ()
697 {
698   register struct breakpoint *b;
699
700   ALL_BREAKPOINTS (b)
701     b->inserted = 0;
702 }
703
704 /* Clear the "inserted" flag in all breakpoints and delete any breakpoints
705    which should go away between runs of the program.  */
706
707 void
708 breakpoint_init_inferior ()
709 {
710   register struct breakpoint *b, *temp;
711
712   ALL_BREAKPOINTS_SAFE (b, temp)
713     {
714       b->inserted = 0;
715
716       /* If the call dummy breakpoint is at the entry point it will
717          cause problems when the inferior is rerun, so we better
718          get rid of it.  */
719       if (b->type == bp_call_dummy)
720         delete_breakpoint (b);
721
722       /* Likewise for scope breakpoints.  */
723       if (b->type == bp_watchpoint_scope)
724         delete_breakpoint (b);
725
726       /* Likewise for watchpoints on local expressions.  */
727       if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint ||
728            b->type == bp_read_watchpoint || b->type == bp_access_watchpoint)
729           && b->exp_valid_block != NULL)
730         delete_breakpoint (b);
731     }
732 }
733
734 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
735    When continuing from a location with a breakpoint,
736    we actually single step once before calling insert_breakpoints.  */
737
738 int
739 breakpoint_here_p (pc)
740      CORE_ADDR pc;
741 {
742   register struct breakpoint *b;
743
744   ALL_BREAKPOINTS (b)
745     if (b->enable != disabled && b->address == pc)
746       return 1;
747
748   return 0;
749 }
750
751 /* Return nonzero if FRAME is a dummy frame.  We can't use PC_IN_CALL_DUMMY
752    because figuring out the saved SP would take too much time, at least using
753    get_saved_register on the 68k.  This means that for this function to
754    work right a port must use the bp_call_dummy breakpoint.  */
755
756 int
757 frame_in_dummy (frame)
758      struct frame_info *frame;
759 {
760   struct breakpoint *b;
761
762 #ifdef CALL_DUMMY
763   ALL_BREAKPOINTS (b)
764     {
765       static unsigned LONGEST dummy[] = CALL_DUMMY;
766
767       if (b->type == bp_call_dummy
768           && b->frame == frame->frame
769
770           /* We need to check the PC as well as the frame on the sparc,
771              for signals.exp in the testsuite.  */
772           && (frame->pc
773               >= (b->address
774                   - sizeof (dummy) / sizeof (LONGEST) * REGISTER_SIZE))
775           && frame->pc <= b->address)
776         return 1;
777     }
778 #endif /* CALL_DUMMY */
779   return 0;
780 }
781
782 /* breakpoint_match_thread (PC, PID) returns true if the breakpoint at PC
783    is valid for process/thread PID.  */
784
785 int
786 breakpoint_thread_match (pc, pid)
787      CORE_ADDR pc;
788      int pid;
789 {
790   struct breakpoint *b;
791   int thread;
792
793   thread = pid_to_thread_id (pid);
794
795   ALL_BREAKPOINTS (b)
796     if (b->enable != disabled
797         && b->address == pc
798         && (b->thread == -1 || b->thread == thread))
799       return 1;
800
801   return 0;
802 }
803
804 \f
805 /* bpstat stuff.  External routines' interfaces are documented
806    in breakpoint.h.  */
807
808 /* Clear a bpstat so that it says we are not at any breakpoint.
809    Also free any storage that is part of a bpstat.  */
810
811 void
812 bpstat_clear (bsp)
813      bpstat *bsp;
814 {
815   bpstat p;
816   bpstat q;
817
818   if (bsp == 0)
819     return;
820   p = *bsp;
821   while (p != NULL)
822     {
823       q = p->next;
824       if (p->old_val != NULL)
825         value_free (p->old_val);
826       free ((PTR)p);
827       p = q;
828     }
829   *bsp = NULL;
830 }
831
832 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
833    is part of the bpstat is copied as well.  */
834
835 bpstat
836 bpstat_copy (bs)
837      bpstat bs;
838 {
839   bpstat p = NULL;
840   bpstat tmp;
841   bpstat retval = NULL;
842
843   if (bs == NULL)
844     return bs;
845
846   for (; bs != NULL; bs = bs->next)
847     {
848       tmp = (bpstat) xmalloc (sizeof (*tmp));
849       memcpy (tmp, bs, sizeof (*tmp));
850       if (p == NULL)
851         /* This is the first thing in the chain.  */
852         retval = tmp;
853       else
854         p->next = tmp;
855       p = tmp;
856     }
857   p->next = NULL;
858   return retval;
859 }
860
861 /* Find the bpstat associated with this breakpoint */
862
863 bpstat
864 bpstat_find_breakpoint(bsp, breakpoint)
865      bpstat bsp;
866      struct breakpoint *breakpoint;
867 {
868   if (bsp == NULL) return NULL;
869
870   for (;bsp != NULL; bsp = bsp->next) {
871     if (bsp->breakpoint_at == breakpoint) return bsp;
872   }
873   return NULL;
874 }
875
876 /* Return the breakpoint number of the first breakpoint we are stopped
877    at.  *BSP upon return is a bpstat which points to the remaining
878    breakpoints stopped at (but which is not guaranteed to be good for
879    anything but further calls to bpstat_num).
880    Return 0 if passed a bpstat which does not indicate any breakpoints.  */
881
882 int
883 bpstat_num (bsp)
884      bpstat *bsp;
885 {
886   struct breakpoint *b;
887
888   if ((*bsp) == NULL)
889     return 0;                   /* No more breakpoint values */
890   else
891     {
892       b = (*bsp)->breakpoint_at;
893       *bsp = (*bsp)->next;
894       if (b == NULL)
895         return -1;              /* breakpoint that's been deleted since */
896       else
897         return b->number;       /* We have its number */
898     }
899 }
900
901 /* Modify BS so that the actions will not be performed.  */
902
903 void
904 bpstat_clear_actions (bs)
905      bpstat bs;
906 {
907   for (; bs != NULL; bs = bs->next)
908     {
909       bs->commands = NULL;
910       if (bs->old_val != NULL)
911         {
912           value_free (bs->old_val);
913           bs->old_val = NULL;
914         }
915     }
916 }
917
918 /* Stub for cleaning up our state if we error-out of a breakpoint command */
919 /* ARGSUSED */
920 static void
921 cleanup_executing_breakpoints (ignore)
922      int ignore;
923 {
924   executing_breakpoint_commands = 0;
925 }
926
927 /* Execute all the commands associated with all the breakpoints at this
928    location.  Any of these commands could cause the process to proceed
929    beyond this point, etc.  We look out for such changes by checking
930    the global "breakpoint_proceeded" after each command.  */
931
932 void
933 bpstat_do_actions (bsp)
934      bpstat *bsp;
935 {
936   bpstat bs;
937   struct cleanup *old_chain;
938
939   executing_breakpoint_commands = 1;
940   old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
941
942 top:
943   bs = *bsp;
944
945   breakpoint_proceeded = 0;
946   for (; bs != NULL; bs = bs->next)
947     {
948       while (bs->commands)
949         {
950           char *line = bs->commands->line;
951           bs->commands = bs->commands->next;
952           execute_command (line, 0);
953           /* If the inferior is proceeded by the command, bomb out now.
954              The bpstat chain has been blown away by wait_for_inferior.
955              But since execution has stopped again, there is a new bpstat
956              to look at, so start over.  */
957           if (breakpoint_proceeded)
958             goto top;
959         }
960     }
961
962   executing_breakpoint_commands = 0;
963   discard_cleanups (old_chain);
964 }
965
966 /* This is the normal print_it function for a bpstat.  In the future,
967    much of this logic could (should?) be moved to bpstat_stop_status,
968    by having it set different print_it functions.  */
969
970 static int
971 print_it_normal (bs)
972      bpstat bs;
973 {
974   /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
975      which has since been deleted.  */
976   if (bs->breakpoint_at == NULL
977       || (bs->breakpoint_at->type != bp_breakpoint
978           && bs->breakpoint_at->type != bp_hardware_breakpoint
979           && bs->breakpoint_at->type != bp_watchpoint
980           && bs->breakpoint_at->type != bp_read_watchpoint
981           && bs->breakpoint_at->type != bp_access_watchpoint
982           && bs->breakpoint_at->type != bp_hardware_watchpoint))
983     return 0;
984
985   if (bs->breakpoint_at->type == bp_breakpoint ||
986       bs->breakpoint_at->type == bp_hardware_breakpoint)
987     {
988       /* I think the user probably only wants to see one breakpoint
989          number, not all of them.  */
990       annotate_breakpoint (bs->breakpoint_at->number);
991       printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
992       return 0;
993     }
994   else if ((bs->old_val != NULL) &&
995         (bs->breakpoint_at->type == bp_watchpoint ||
996          bs->breakpoint_at->type == bp_access_watchpoint ||
997          bs->breakpoint_at->type == bp_hardware_watchpoint))
998     {
999       annotate_watchpoint (bs->breakpoint_at->number);
1000       mention (bs->breakpoint_at);
1001       printf_filtered ("\nOld value = ");
1002       value_print (bs->old_val, gdb_stdout, 0, Val_pretty_default);
1003       printf_filtered ("\nNew value = ");
1004       value_print (bs->breakpoint_at->val, gdb_stdout, 0,
1005                    Val_pretty_default);
1006       printf_filtered ("\n");
1007       value_free (bs->old_val);
1008       bs->old_val = NULL;
1009       /* More than one watchpoint may have been triggered.  */
1010       return -1;
1011     }
1012   else if (bs->breakpoint_at->type == bp_access_watchpoint ||
1013            bs->breakpoint_at->type == bp_read_watchpoint)
1014     {
1015       mention (bs->breakpoint_at);
1016       printf_filtered ("\nValue = ");
1017       value_print (bs->breakpoint_at->val, gdb_stdout, 0,
1018                    Val_pretty_default);
1019       printf_filtered ("\n");
1020       return -1;
1021     }
1022   /* We can't deal with it.  Maybe another member of the bpstat chain can.  */
1023   return -1;
1024 }
1025
1026 /* Print a message indicating what happened.  Returns nonzero to
1027    say that only the source line should be printed after this (zero
1028    return means print the frame as well as the source line).  */
1029 /* Currently we always return zero.  */
1030 int
1031 bpstat_print (bs)
1032      bpstat bs;
1033 {
1034   int val;
1035   
1036   if (bs == NULL)
1037     return 0;
1038
1039   val = (*bs->print_it) (bs);
1040   if (val >= 0)
1041     return val;
1042   
1043   /* Maybe another breakpoint in the chain caused us to stop.
1044      (Currently all watchpoints go on the bpstat whether hit or
1045      not.  That probably could (should) be changed, provided care is taken
1046      with respect to bpstat_explains_signal).  */
1047   if (bs->next)
1048     return bpstat_print (bs->next);
1049
1050   /* We reached the end of the chain without printing anything.  */
1051   return 0;
1052 }
1053
1054 /* Evaluate the expression EXP and return 1 if value is zero.
1055    This is used inside a catch_errors to evaluate the breakpoint condition. 
1056    The argument is a "struct expression *" that has been cast to char * to 
1057    make it pass through catch_errors.  */
1058
1059 static int
1060 breakpoint_cond_eval (exp)
1061      char *exp;
1062 {
1063   value_ptr mark = value_mark ();
1064   int i = !value_true (evaluate_expression ((struct expression *)exp));
1065   value_free_to_mark (mark);
1066   return i;
1067 }
1068
1069 /* Allocate a new bpstat and chain it to the current one.  */
1070
1071 static bpstat
1072 bpstat_alloc (b, cbs)
1073      register struct breakpoint *b;
1074      bpstat cbs;                        /* Current "bs" value */
1075 {
1076   bpstat bs;
1077
1078   bs = (bpstat) xmalloc (sizeof (*bs));
1079   cbs->next = bs;
1080   bs->breakpoint_at = b;
1081   /* If the condition is false, etc., don't do the commands.  */
1082   bs->commands = NULL;
1083   bs->old_val = NULL;
1084   bs->print_it = print_it_normal;
1085   return bs;
1086 }
1087 \f
1088 /* Possible return values for watchpoint_check (this can't be an enum
1089    because of check_errors).  */
1090 /* The watchpoint has been deleted.  */
1091 #define WP_DELETED 1
1092 /* The value has changed.  */
1093 #define WP_VALUE_CHANGED 2
1094 /* The value has not changed.  */
1095 #define WP_VALUE_NOT_CHANGED 3
1096
1097 /* Check watchpoint condition.  */
1098
1099 static int
1100 watchpoint_check (p)
1101      char *p;
1102 {
1103   bpstat bs = (bpstat) p;
1104   struct breakpoint *b;
1105   struct frame_info *saved_frame, *fr;
1106   int within_current_scope, saved_level;
1107
1108   b = bs->breakpoint_at;
1109
1110   if (b->exp_valid_block == NULL)
1111     within_current_scope = 1;
1112   else
1113     {
1114       /* There is no current frame at this moment.  If we're going to have
1115          any chance of handling watchpoints on local variables, we'll need
1116          the frame chain (so we can determine if we're in scope).  */
1117       reinit_frame_cache();
1118       fr = find_frame_addr_in_frame_chain (b->watchpoint_frame);
1119       within_current_scope = (fr != NULL);
1120       if (within_current_scope)
1121         /* If we end up stopping, the current frame will get selected
1122            in normal_stop.  So this call to select_frame won't affect
1123            the user.  */
1124         select_frame (fr, -1);
1125     }
1126       
1127   if (within_current_scope)
1128     {
1129       /* We use value_{,free_to_}mark because it could be a
1130          *long* time before we return to the command level and
1131          call free_all_values.  We can't call free_all_values because
1132          we might be in the middle of evaluating a function call.  */
1133
1134       value_ptr mark = value_mark ();
1135       value_ptr new_val = evaluate_expression (bs->breakpoint_at->exp);
1136       if (!value_equal (b->val, new_val))
1137         {
1138           release_value (new_val);
1139           value_free_to_mark (mark);
1140           bs->old_val = b->val;
1141           b->val = new_val;
1142           /* We will stop here */
1143           return WP_VALUE_CHANGED;
1144         }
1145       else
1146         {
1147           /* Nothing changed, don't do anything.  */
1148           value_free_to_mark (mark);
1149           /* We won't stop here */
1150           return WP_VALUE_NOT_CHANGED;
1151         }
1152     }
1153   else
1154     {
1155       /* This seems like the only logical thing to do because
1156          if we temporarily ignored the watchpoint, then when
1157          we reenter the block in which it is valid it contains
1158          garbage (in the case of a function, it may have two
1159          garbage values, one before and one after the prologue).
1160          So we can't even detect the first assignment to it and
1161          watch after that (since the garbage may or may not equal
1162          the first value assigned).  */
1163       printf_filtered ("\
1164 Watchpoint %d deleted because the program has left the block in\n\
1165 which its expression is valid.\n", bs->breakpoint_at->number);
1166       if (b->related_breakpoint)
1167         delete_breakpoint (b->related_breakpoint);
1168       delete_breakpoint (b);
1169
1170       return WP_DELETED;
1171     }
1172 }
1173
1174 /* This is used when everything which needs to be printed has
1175    already been printed.  But we still want to print the frame.  */
1176 static int
1177 print_it_done (bs)
1178      bpstat bs;
1179 {
1180   return 0;
1181 }
1182
1183 /* This is used when nothing should be printed for this bpstat entry.  */
1184
1185 static int
1186 print_it_noop (bs)
1187      bpstat bs;
1188 {
1189   return -1;
1190 }
1191
1192 /* Get a bpstat associated with having just stopped at address *PC
1193    and frame address CORE_ADDRESS.  Update *PC to point at the
1194    breakpoint (if we hit a breakpoint).  NOT_A_BREAKPOINT is nonzero
1195    if this is known to not be a real breakpoint (it could still be a
1196    watchpoint, though).  */
1197
1198 /* Determine whether we stopped at a breakpoint, etc, or whether we
1199    don't understand this stop.  Result is a chain of bpstat's such that:
1200
1201         if we don't understand the stop, the result is a null pointer.
1202
1203         if we understand why we stopped, the result is not null.
1204
1205         Each element of the chain refers to a particular breakpoint or
1206         watchpoint at which we have stopped.  (We may have stopped for
1207         several reasons concurrently.)
1208
1209         Each element of the chain has valid next, breakpoint_at,
1210         commands, FIXME??? fields.
1211
1212  */
1213
1214 bpstat
1215 bpstat_stop_status (pc, not_a_breakpoint)
1216      CORE_ADDR *pc;
1217      int not_a_breakpoint;
1218 {
1219   register struct breakpoint *b;
1220   CORE_ADDR bp_addr;
1221 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1222   /* True if we've hit a breakpoint (as opposed to a watchpoint).  */
1223   int real_breakpoint = 0;
1224 #endif
1225   /* Root of the chain of bpstat's */
1226   struct bpstat root_bs[1];
1227   /* Pointer to the last thing in the chain currently.  */
1228   bpstat bs = root_bs;
1229   static char message1[] =
1230             "Error evaluating expression for watchpoint %d\n";
1231   char message[sizeof (message1) + 30 /* slop */];
1232
1233   /* Get the address where the breakpoint would have been.  */
1234   bp_addr = *pc - DECR_PC_AFTER_BREAK;
1235
1236   ALL_BREAKPOINTS (b)
1237     {
1238       if (b->enable == disabled)
1239         continue;
1240
1241       if (b->type != bp_watchpoint
1242           && b->type != bp_hardware_watchpoint
1243           && b->type != bp_read_watchpoint
1244           && b->type != bp_access_watchpoint
1245           && b->type != bp_hardware_breakpoint
1246           && b->address != bp_addr)
1247         continue;
1248
1249 #ifndef DECR_PC_AFTER_HW_BREAK
1250 #define DECR_PC_AFTER_HW_BREAK 0
1251 #endif
1252       if (b->type == bp_hardware_breakpoint
1253           && b->address != (bp_addr - DECR_PC_AFTER_HW_BREAK))
1254         continue;
1255
1256       if (b->type != bp_watchpoint
1257           && b->type != bp_hardware_watchpoint
1258           && b->type != bp_read_watchpoint
1259           && b->type != bp_access_watchpoint
1260           && not_a_breakpoint)
1261         continue;
1262
1263       /* Come here if it's a watchpoint, or if the break address matches */
1264
1265       ++(b->hit_count);
1266
1267       bs = bpstat_alloc (b, bs);        /* Alloc a bpstat to explain stop */
1268
1269       bs->stop = 1;
1270       bs->print = 1;
1271
1272       sprintf (message, message1, b->number);
1273       if (b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
1274         {
1275           switch (catch_errors (watchpoint_check, (char *) bs, message,
1276                                 RETURN_MASK_ALL))
1277             {
1278             case WP_DELETED:
1279               /* We've already printed what needs to be printed.  */
1280               bs->print_it = print_it_done;
1281               /* Stop.  */
1282               break;
1283             case WP_VALUE_CHANGED:
1284               /* Stop.  */
1285               break;
1286             case WP_VALUE_NOT_CHANGED:
1287               /* Don't stop.  */
1288               bs->print_it = print_it_noop;
1289               bs->stop = 0;
1290               continue;
1291             default:
1292               /* Can't happen.  */
1293               /* FALLTHROUGH */
1294             case 0:
1295               /* Error from catch_errors.  */
1296               printf_filtered ("Watchpoint %d deleted.\n", b->number);
1297               if (b->related_breakpoint)
1298                 delete_breakpoint (b->related_breakpoint);
1299               delete_breakpoint (b);
1300               /* We've already printed what needs to be printed.  */
1301               bs->print_it = print_it_done;
1302
1303               /* Stop.  */
1304               break;
1305             }
1306         }
1307       else if (b->type == bp_read_watchpoint || b->type == bp_access_watchpoint)
1308         {
1309           CORE_ADDR addr;
1310           value_ptr v;
1311           int found = 0;
1312
1313           addr = target_stopped_data_address();
1314           if (addr == 0) continue;
1315           for (v = b->val_chain; v; v = v->next)
1316             {
1317               if (v->lval == lval_memory)
1318                 {
1319                   CORE_ADDR vaddr;
1320
1321                   vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
1322                   if (addr == vaddr)
1323                     found = 1;
1324                 }
1325             }
1326           if (found) 
1327             switch (catch_errors (watchpoint_check, (char *) bs, message,
1328                          RETURN_MASK_ALL))
1329               {
1330                 case WP_DELETED:
1331                   /* We've already printed what needs to be printed.  */
1332                   bs->print_it = print_it_done;
1333                   /* Stop.  */
1334                   break;
1335                 case WP_VALUE_CHANGED:
1336                 case WP_VALUE_NOT_CHANGED:
1337                   /* Stop.  */
1338                   break;
1339                 default:
1340                   /* Can't happen.  */
1341                 case 0:
1342                   /* Error from catch_errors.  */
1343                   printf_filtered ("Watchpoint %d deleted.\n", b->number);
1344                   if (b->related_breakpoint)
1345                     delete_breakpoint (b->related_breakpoint);
1346                   delete_breakpoint (b);
1347                   /* We've already printed what needs to be printed.  */
1348                   bs->print_it = print_it_done;
1349                   break;
1350               }
1351         }
1352 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1353       else
1354         real_breakpoint = 1;
1355 #endif
1356
1357       if (b->frame && b->frame != (get_current_frame ())->frame)
1358         bs->stop = 0;
1359       else
1360         {
1361           int value_is_zero = 0;
1362
1363           if (b->cond)
1364             {
1365               /* Need to select the frame, with all that implies
1366                  so that the conditions will have the right context.  */
1367               select_frame (get_current_frame (), 0);
1368               value_is_zero
1369                 = catch_errors (breakpoint_cond_eval, (char *)(b->cond),
1370                                 "Error in testing breakpoint condition:\n",
1371                                 RETURN_MASK_ALL);
1372                                 /* FIXME-someday, should give breakpoint # */
1373               free_all_values ();
1374             }
1375           if (b->cond && value_is_zero)
1376             {
1377               bs->stop = 0;
1378             }
1379           else if (b->ignore_count > 0)
1380             {
1381               b->ignore_count--;
1382               bs->stop = 0;
1383             }
1384           else
1385             {
1386               /* We will stop here */
1387               if (b->disposition == disable)
1388                 b->enable = disabled;
1389               bs->commands = b->commands;
1390               if (b->silent)
1391                 bs->print = 0;
1392               if (bs->commands && STREQ ("silent", bs->commands->line))
1393                 {
1394                   bs->commands = bs->commands->next;
1395                   bs->print = 0;
1396                 }
1397             }
1398         }
1399       /* Print nothing for this entry if we dont stop or if we dont print.  */
1400       if (bs->stop == 0 || bs->print == 0)
1401         bs->print_it = print_it_noop;
1402     }
1403
1404   bs->next = NULL;              /* Terminate the chain */
1405   bs = root_bs->next;           /* Re-grab the head of the chain */
1406 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
1407   if (bs)
1408     {
1409       if (real_breakpoint)
1410         {
1411           *pc = bp_addr;
1412 #if defined (SHIFT_INST_REGS)
1413           SHIFT_INST_REGS();
1414 #else /* No SHIFT_INST_REGS.  */
1415           write_pc (bp_addr);
1416 #endif /* No SHIFT_INST_REGS.  */
1417         }
1418     }
1419 #endif /* DECR_PC_AFTER_BREAK != 0.  */
1420
1421   /* The value of a hardware watchpoint hasn't changed, but the
1422      intermediate memory locations we are watching may have.  */
1423   if (bs && ! bs->stop &&
1424       (bs->breakpoint_at->type == bp_hardware_watchpoint ||
1425        bs->breakpoint_at->type == bp_read_watchpoint ||
1426        bs->breakpoint_at->type == bp_access_watchpoint))
1427     {
1428       remove_breakpoints ();
1429       insert_breakpoints ();
1430     }
1431   return bs;
1432 }
1433 \f
1434 /* Tell what to do about this bpstat.  */
1435 struct bpstat_what
1436 bpstat_what (bs)
1437      bpstat bs;
1438 {
1439   /* Classify each bpstat as one of the following.  */
1440   enum class {
1441     /* This bpstat element has no effect on the main_action.  */
1442     no_effect = 0,
1443
1444     /* There was a watchpoint, stop but don't print.  */
1445     wp_silent,
1446
1447     /* There was a watchpoint, stop and print.  */
1448     wp_noisy,
1449
1450     /* There was a breakpoint but we're not stopping.  */
1451     bp_nostop,
1452
1453     /* There was a breakpoint, stop but don't print.  */
1454     bp_silent,
1455
1456     /* There was a breakpoint, stop and print.  */
1457     bp_noisy,
1458
1459     /* We hit the longjmp breakpoint.  */
1460     long_jump,
1461
1462     /* We hit the longjmp_resume breakpoint.  */
1463     long_resume,
1464
1465     /* We hit the step_resume breakpoint.  */
1466     step_resume,
1467
1468     /* We hit the through_sigtramp breakpoint.  */
1469     through_sig,
1470
1471     /* This is just used to count how many enums there are.  */
1472     class_last
1473     };
1474
1475   /* Here is the table which drives this routine.  So that we can
1476      format it pretty, we define some abbreviations for the
1477      enum bpstat_what codes.  */
1478 #define keep_c BPSTAT_WHAT_KEEP_CHECKING
1479 #define stop_s BPSTAT_WHAT_STOP_SILENT
1480 #define stop_n BPSTAT_WHAT_STOP_NOISY
1481 #define single BPSTAT_WHAT_SINGLE
1482 #define setlr BPSTAT_WHAT_SET_LONGJMP_RESUME
1483 #define clrlr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
1484 #define clrlrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
1485 #define sr BPSTAT_WHAT_STEP_RESUME
1486 #define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
1487
1488 /* "Can't happen."  Might want to print an error message.
1489    abort() is not out of the question, but chances are GDB is just
1490    a bit confused, not unusable.  */
1491 #define err BPSTAT_WHAT_STOP_NOISY
1492
1493   /* Given an old action and a class, come up with a new action.  */
1494   /* One interesting property of this table is that wp_silent is the same
1495      as bp_silent and wp_noisy is the same as bp_noisy.  That is because
1496      after stopping, the check for whether to step over a breakpoint
1497      (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
1498      reference to how we stopped.  We retain separate wp_silent and bp_silent
1499      codes in case we want to change that someday.  */
1500
1501   /* step_resume entries: a step resume breakpoint overrides another
1502      breakpoint of signal handling (see comment in wait_for_inferior
1503      at first IN_SIGTRAMP where we set the step_resume breakpoint).  */
1504   /* We handle the through_sigtramp_breakpoint the same way; having both
1505      one of those and a step_resume_breakpoint is probably very rare (?).  */
1506
1507   static const enum bpstat_what_main_action
1508     table[(int)class_last][(int)BPSTAT_WHAT_LAST] =
1509       {
1510         /*                              old action */
1511         /*       keep_c stop_s stop_n single  setlr   clrlr   clrlrs  sr  ts
1512          */
1513 /*no_effect*/   {keep_c,stop_s,stop_n,single, setlr , clrlr , clrlrs, sr, ts},
1514 /*wp_silent*/   {stop_s,stop_s,stop_n,stop_s, stop_s, stop_s, stop_s, sr, ts},
1515 /*wp_noisy*/    {stop_n,stop_n,stop_n,stop_n, stop_n, stop_n, stop_n, sr, ts},
1516 /*bp_nostop*/   {single,stop_s,stop_n,single, setlr , clrlrs, clrlrs, sr, ts},
1517 /*bp_silent*/   {stop_s,stop_s,stop_n,stop_s, stop_s, stop_s, stop_s, sr, ts},
1518 /*bp_noisy*/    {stop_n,stop_n,stop_n,stop_n, stop_n, stop_n, stop_n, sr, ts},
1519 /*long_jump*/   {setlr ,stop_s,stop_n,setlr , err   , err   , err   , sr, ts},
1520 /*long_resume*/ {clrlr ,stop_s,stop_n,clrlrs, err   , err   , err   , sr, ts},
1521 /*step_resume*/ {sr    ,sr    ,sr    ,sr    , sr    , sr    , sr    , sr, ts},
1522 /*through_sig*/ {ts    ,ts    ,ts    ,ts    , ts    , ts    , ts    , ts, ts}
1523               };
1524 #undef keep_c
1525 #undef stop_s
1526 #undef stop_n
1527 #undef single
1528 #undef setlr
1529 #undef clrlr
1530 #undef clrlrs
1531 #undef err
1532 #undef sr
1533 #undef ts
1534   enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
1535   struct bpstat_what retval;
1536
1537   retval.call_dummy = 0;
1538   for (; bs != NULL; bs = bs->next)
1539     {
1540       enum class bs_class = no_effect;
1541       if (bs->breakpoint_at == NULL)
1542         /* I suspect this can happen if it was a momentary breakpoint
1543            which has since been deleted.  */
1544         continue;
1545       switch (bs->breakpoint_at->type)
1546         {
1547         case bp_breakpoint:
1548         case bp_hardware_breakpoint:
1549         case bp_until:
1550         case bp_finish:
1551           if (bs->stop)
1552             {
1553               if (bs->print)
1554                 bs_class = bp_noisy;
1555               else
1556                 bs_class = bp_silent;
1557             }
1558           else
1559             bs_class = bp_nostop;
1560           break;
1561         case bp_watchpoint:
1562         case bp_hardware_watchpoint:
1563         case bp_read_watchpoint:
1564         case bp_access_watchpoint:
1565           if (bs->stop)
1566             {
1567               if (bs->print)
1568                 bs_class = wp_noisy;
1569               else
1570                 bs_class = wp_silent;
1571             }
1572           else
1573             /* There was a watchpoint, but we're not stopping.  This requires
1574                no further action.  */
1575             bs_class = no_effect;
1576           break;
1577         case bp_longjmp:
1578           bs_class = long_jump;
1579           break;
1580         case bp_longjmp_resume:
1581           bs_class = long_resume;
1582           break;
1583         case bp_step_resume:
1584           if (bs->stop)
1585             {
1586               bs_class = step_resume;
1587             }
1588           else
1589             /* It is for the wrong frame.  */
1590             bs_class = bp_nostop;
1591           break;
1592         case bp_through_sigtramp:
1593           bs_class = through_sig;
1594           break;
1595         case bp_watchpoint_scope:
1596           bs_class = bp_nostop;
1597           break;
1598
1599         case bp_call_dummy:
1600           /* Make sure the action is stop (silent or noisy), so infrun.c
1601              pops the dummy frame.  */
1602           bs_class = bp_silent;
1603           retval.call_dummy = 1;
1604           break;
1605         }
1606       current_action = table[(int)bs_class][(int)current_action];
1607     }
1608   retval.main_action = current_action;
1609   return retval;
1610 }
1611
1612 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1613    without hardware support).  This isn't related to a specific bpstat,
1614    just to things like whether watchpoints are set.  */
1615
1616 int 
1617 bpstat_should_step ()
1618 {
1619   struct breakpoint *b;
1620   ALL_BREAKPOINTS (b)
1621     if (b->enable == enabled && b->type == bp_watchpoint)
1622       return 1;
1623   return 0;
1624 }
1625 \f
1626 /* Print information on breakpoint number BNUM, or -1 if all.
1627    If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
1628    is nonzero, process only watchpoints.  */
1629
1630 static void
1631 breakpoint_1 (bnum, allflag)
1632      int bnum;
1633      int allflag;
1634 {
1635   register struct breakpoint *b;
1636   register struct command_line *l;
1637   register struct symbol *sym;
1638   CORE_ADDR last_addr = (CORE_ADDR)-1;
1639   int found_a_breakpoint = 0;
1640   static char *bptypes[] = {"breakpoint", "hw breakpoint",
1641                               "until", "finish", "watchpoint",
1642                               "hw watchpoint", "read watchpoint",
1643                               "acc watchpoint", "longjmp",
1644                               "longjmp resume", "step resume",
1645                               "watchpoint scope", "call dummy" };
1646   static char *bpdisps[] = {"del", "dis", "keep"};
1647   static char bpenables[] = "ny";
1648   char wrap_indent[80];
1649
1650   ALL_BREAKPOINTS (b)
1651     if (bnum == -1
1652         || bnum == b->number)
1653       {
1654 /*  We only print out user settable breakpoints unless the allflag is set. */
1655         if (!allflag
1656             && b->type != bp_breakpoint
1657             && b->type != bp_hardware_breakpoint
1658             && b->type != bp_watchpoint
1659             && b->type != bp_read_watchpoint
1660             && b->type != bp_access_watchpoint
1661             && b->type != bp_hardware_watchpoint)
1662           continue;
1663
1664         if (!found_a_breakpoint++)
1665           {
1666             annotate_breakpoints_headers ();
1667   
1668             annotate_field (0);
1669             printf_filtered ("Num ");
1670             annotate_field (1);
1671             printf_filtered ("Type           ");
1672             annotate_field (2);
1673             printf_filtered ("Disp ");
1674             annotate_field (3);
1675             printf_filtered ("Enb ");
1676             if (addressprint)
1677               {
1678                 annotate_field (4);
1679                 printf_filtered ("Address    ");
1680               }
1681             annotate_field (5);
1682             printf_filtered ("What\n");
1683   
1684             annotate_breakpoints_table ();
1685           }
1686   
1687         annotate_record ();
1688         annotate_field (0);
1689         printf_filtered ("%-3d ", b->number);
1690         annotate_field (1);
1691         printf_filtered ("%-14s ", bptypes[(int)b->type]);
1692         annotate_field (2);
1693         printf_filtered ("%-4s ", bpdisps[(int)b->disposition]);
1694         annotate_field (3);
1695         printf_filtered ("%-3c ", bpenables[(int)b->enable]);
1696
1697         strcpy (wrap_indent, "                           ");
1698         if (addressprint)
1699           strcat (wrap_indent, "           ");
1700         switch (b->type)
1701           {
1702           case bp_watchpoint:
1703           case bp_hardware_watchpoint:
1704           case bp_read_watchpoint:
1705           case bp_access_watchpoint:
1706             /* Field 4, the address, is omitted (which makes the columns
1707                not line up too nicely with the headers, but the effect
1708                is relatively readable).  */
1709             annotate_field (5);
1710             print_expression (b->exp, gdb_stdout);
1711             break;
1712
1713           case bp_breakpoint:
1714           case bp_hardware_breakpoint:
1715           case bp_until:
1716           case bp_finish:
1717           case bp_longjmp:
1718           case bp_longjmp_resume:
1719           case bp_step_resume:
1720           case bp_through_sigtramp:
1721           case bp_watchpoint_scope:
1722           case bp_call_dummy:
1723             if (addressprint)
1724               {
1725                 annotate_field (4);
1726                 /* FIXME-32x64: need a print_address_numeric with
1727                    field width */
1728                 printf_filtered
1729                   ("%s ",
1730                    local_hex_string_custom
1731                    ((unsigned long) b->address, "08l"));
1732               }
1733
1734             annotate_field (5);
1735
1736             last_addr = b->address;
1737             if (b->source_file)
1738               {
1739                 sym = find_pc_function (b->address);
1740                 if (sym)
1741                   {
1742                     fputs_filtered ("in ", gdb_stdout);
1743                     fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
1744                     wrap_here (wrap_indent);
1745                     fputs_filtered (" at ", gdb_stdout);
1746                   }
1747                 fputs_filtered (b->source_file, gdb_stdout);
1748                 printf_filtered (":%d", b->line_number);
1749               }
1750             else
1751               print_address_symbolic (b->address, gdb_stdout, demangle, " ");
1752             break;
1753           }
1754
1755         printf_filtered ("\n");
1756
1757         if (b->frame)
1758           {
1759             annotate_field (6);
1760
1761             printf_filtered ("\tstop only in stack frame at ");
1762             print_address_numeric (b->frame, 1, gdb_stdout);
1763             printf_filtered ("\n");
1764           }
1765
1766         if (b->cond)
1767           {
1768             annotate_field (7);
1769
1770             printf_filtered ("\tstop only if ");
1771             print_expression (b->cond, gdb_stdout);
1772             printf_filtered ("\n");
1773           }
1774
1775         if (show_breakpoint_hit_counts && b->hit_count)
1776           {
1777             /* FIXME should make an annotation for this */
1778
1779             printf_filtered ("\tbreakpoint already hit %d time%s\n",
1780                              b->hit_count, (b->hit_count == 1 ? "" : "s"));
1781           }
1782
1783         if (b->ignore_count)
1784           {
1785             annotate_field (8);
1786
1787             printf_filtered ("\tignore next %d hits\n", b->ignore_count);
1788           }
1789
1790         if ((l = b->commands))
1791           {
1792             annotate_field (9);
1793
1794             while (l)
1795               {
1796                 fputs_filtered ("\t", gdb_stdout);
1797                 fputs_filtered (l->line, gdb_stdout);
1798                 fputs_filtered ("\n", gdb_stdout);
1799                 l = l->next;
1800               }
1801           }
1802       }
1803
1804   if (!found_a_breakpoint)
1805     {
1806       if (bnum == -1)
1807         printf_filtered ("No breakpoints or watchpoints.\n");
1808       else
1809         printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
1810     }
1811   else
1812     /* Compare against (CORE_ADDR)-1 in case some compiler decides
1813        that a comparison of an unsigned with -1 is always false.  */
1814     if (last_addr != (CORE_ADDR)-1)
1815       set_next_address (last_addr);
1816
1817   annotate_breakpoints_table_end ();
1818 }
1819
1820 /* ARGSUSED */
1821 static void
1822 breakpoints_info (bnum_exp, from_tty)
1823      char *bnum_exp;
1824      int from_tty;
1825 {
1826   int bnum = -1;
1827
1828   if (bnum_exp)
1829     bnum = parse_and_eval_address (bnum_exp);
1830
1831   breakpoint_1 (bnum, 0);
1832 }
1833
1834 #if MAINTENANCE_CMDS
1835
1836 /* ARGSUSED */
1837 static void
1838 maintenance_info_breakpoints (bnum_exp, from_tty)
1839      char *bnum_exp;
1840      int from_tty;
1841 {
1842   int bnum = -1;
1843
1844   if (bnum_exp)
1845     bnum = parse_and_eval_address (bnum_exp);
1846
1847   breakpoint_1 (bnum, 1);
1848 }
1849
1850 #endif
1851
1852 /* Print a message describing any breakpoints set at PC.  */
1853
1854 static void
1855 describe_other_breakpoints (pc)
1856      register CORE_ADDR pc;
1857 {
1858   register int others = 0;
1859   register struct breakpoint *b;
1860
1861   ALL_BREAKPOINTS (b)
1862     if (b->address == pc)
1863       others++;
1864   if (others > 0)
1865     {
1866       printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
1867       ALL_BREAKPOINTS (b)
1868         if (b->address == pc)
1869           {
1870             others--;
1871             printf_filtered
1872               ("%d%s%s ",
1873                b->number,
1874                (b->enable == disabled) ? " (disabled)" : "",
1875                (others > 1) ? "," : ((others == 1) ? " and" : ""));
1876           }
1877       printf_filtered ("also set at pc ");
1878       print_address_numeric (pc, 1, gdb_stdout);
1879       printf_filtered (".\n");
1880     }
1881 }
1882 \f
1883 /* Set the default place to put a breakpoint
1884    for the `break' command with no arguments.  */
1885
1886 void
1887 set_default_breakpoint (valid, addr, symtab, line)
1888      int valid;
1889      CORE_ADDR addr;
1890      struct symtab *symtab;
1891      int line;
1892 {
1893   default_breakpoint_valid = valid;
1894   default_breakpoint_address = addr;
1895   default_breakpoint_symtab = symtab;
1896   default_breakpoint_line = line;
1897 }
1898
1899 /* Rescan breakpoints at address ADDRESS,
1900    marking the first one as "first" and any others as "duplicates".
1901    This is so that the bpt instruction is only inserted once.  */
1902
1903 static void
1904 check_duplicates (address)
1905      CORE_ADDR address;
1906 {
1907   register struct breakpoint *b;
1908   register int count = 0;
1909
1910   if (address == 0)             /* Watchpoints are uninteresting */
1911     return;
1912
1913   ALL_BREAKPOINTS (b)
1914     if (b->enable != disabled && b->address == address)
1915       {
1916         count++;
1917         b->duplicate = count > 1;
1918       }
1919 }
1920
1921 /* Low level routine to set a breakpoint.
1922    Takes as args the three things that every breakpoint must have.
1923    Returns the breakpoint object so caller can set other things.
1924    Does not set the breakpoint number!
1925    Does not print anything.
1926
1927    ==> This routine should not be called if there is a chance of later
1928    error(); otherwise it leaves a bogus breakpoint on the chain.  Validate
1929    your arguments BEFORE calling this routine!  */
1930
1931 static struct breakpoint *
1932 set_raw_breakpoint (sal)
1933      struct symtab_and_line sal;
1934 {
1935   register struct breakpoint *b, *b1;
1936
1937   b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
1938   memset (b, 0, sizeof (*b));
1939   b->address = sal.pc;
1940   if (sal.symtab == NULL)
1941     b->source_file = NULL;
1942   else
1943     b->source_file = savestring (sal.symtab->filename,
1944                                  strlen (sal.symtab->filename));
1945   b->language = current_language->la_language;
1946   b->input_radix = input_radix;
1947   b->thread = -1;
1948   b->line_number = sal.line;
1949   b->enable = enabled;
1950   b->next = 0;
1951   b->silent = 0;
1952   b->ignore_count = 0;
1953   b->commands = NULL;
1954   b->frame = 0;
1955
1956   /* Add this breakpoint to the end of the chain
1957      so that a list of breakpoints will come out in order
1958      of increasing numbers.  */
1959
1960   b1 = breakpoint_chain;
1961   if (b1 == 0)
1962     breakpoint_chain = b;
1963   else
1964     {
1965       while (b1->next)
1966         b1 = b1->next;
1967       b1->next = b;
1968     }
1969
1970   check_duplicates (sal.pc);
1971   breakpoints_changed ();
1972
1973   return b;
1974 }
1975
1976 static void
1977 create_longjmp_breakpoint(func_name)
1978      char *func_name;
1979 {
1980   struct symtab_and_line sal;
1981   struct breakpoint *b;
1982   static int internal_breakpoint_number = -1;
1983
1984   if (func_name != NULL)
1985     {
1986       struct minimal_symbol *m;
1987
1988       m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
1989       if (m)
1990         sal.pc = SYMBOL_VALUE_ADDRESS (m);
1991       else
1992         return;
1993     }
1994   else
1995     sal.pc = 0;
1996
1997   sal.symtab = NULL;
1998   sal.line = 0;
1999
2000   b = set_raw_breakpoint(sal);
2001   if (!b) return;
2002
2003   b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
2004   b->disposition = donttouch;
2005   b->enable = disabled;
2006   b->silent = 1;
2007   if (func_name)
2008     b->addr_string = strsave(func_name);
2009   b->number = internal_breakpoint_number--;
2010 }
2011
2012 /* Call this routine when stepping and nexting to enable a breakpoint if we do
2013    a longjmp().  When we hit that breakpoint, call
2014    set_longjmp_resume_breakpoint() to figure out where we are going. */
2015
2016 void
2017 enable_longjmp_breakpoint()
2018 {
2019   register struct breakpoint *b;
2020
2021   ALL_BREAKPOINTS (b)
2022     if (b->type == bp_longjmp)
2023       {
2024         b->enable = enabled;
2025         check_duplicates (b->address);
2026       }
2027 }
2028
2029 void
2030 disable_longjmp_breakpoint()
2031 {
2032   register struct breakpoint *b;
2033
2034   ALL_BREAKPOINTS (b)
2035     if (   b->type == bp_longjmp
2036         || b->type == bp_longjmp_resume)
2037       {
2038         b->enable = disabled;
2039         check_duplicates (b->address);
2040       }
2041 }
2042
2043 int
2044 hw_breakpoint_used_count()
2045 {
2046   register struct breakpoint *b;
2047   int i = 0;
2048
2049   ALL_BREAKPOINTS (b)
2050     {
2051       if (b->type == bp_hardware_breakpoint && b->enable == enabled)
2052         i++;
2053     }
2054
2055   return i;
2056 }
2057
2058 int
2059 hw_watchpoint_used_count(type, other_type_used)
2060     enum bptype type;
2061     int *other_type_used;
2062 {
2063   register struct breakpoint *b;
2064   int i = 0;
2065
2066   *other_type_used = 0;
2067   ALL_BREAKPOINTS (b)
2068     {
2069       if (b->enable == enabled)
2070         {
2071           if (b->type == type) i++;
2072           else if ((b->type == bp_hardware_watchpoint ||
2073                b->type == bp_read_watchpoint ||
2074                b->type == bp_access_watchpoint)
2075                && b->enable == enabled)
2076             *other_type_used = 1;
2077         }
2078     }
2079   return i;
2080 }
2081
2082 /* Call this after hitting the longjmp() breakpoint.  Use this to set a new
2083    breakpoint at the target of the jmp_buf.
2084
2085    FIXME - This ought to be done by setting a temporary breakpoint that gets
2086    deleted automatically...
2087 */
2088
2089 void
2090 set_longjmp_resume_breakpoint(pc, frame)
2091      CORE_ADDR pc;
2092      struct frame_info *frame;
2093 {
2094   register struct breakpoint *b;
2095
2096   ALL_BREAKPOINTS (b)
2097     if (b->type == bp_longjmp_resume)
2098       {
2099         b->address = pc;
2100         b->enable = enabled;
2101         if (frame != NULL)
2102           b->frame = frame->frame;
2103         else
2104           b->frame = 0;
2105         check_duplicates (b->address);
2106         return;
2107       }
2108 }
2109
2110 /* Set a breakpoint that will evaporate an end of command
2111    at address specified by SAL.
2112    Restrict it to frame FRAME if FRAME is nonzero.  */
2113
2114 struct breakpoint *
2115 set_momentary_breakpoint (sal, frame, type)
2116      struct symtab_and_line sal;
2117      struct frame_info *frame;
2118      enum bptype type;
2119 {
2120   register struct breakpoint *b;
2121   b = set_raw_breakpoint (sal);
2122   b->type = type;
2123   b->enable = enabled;
2124   b->disposition = donttouch;
2125   b->frame = (frame ? frame->frame : 0);
2126   return b;
2127 }
2128
2129 #if 0
2130 void
2131 clear_momentary_breakpoints ()
2132 {
2133   register struct breakpoint *b;
2134   ALL_BREAKPOINTS (b)
2135     if (b->disposition == delete)
2136       {
2137         delete_breakpoint (b);
2138         break;
2139       }
2140 }
2141 #endif
2142 \f
2143 /* Tell the user we have just set a breakpoint B.  */
2144
2145 static void
2146 mention (b)
2147      struct breakpoint *b;
2148 {
2149   int say_where = 0;
2150
2151   /* FIXME: This is misplaced; mention() is called by things (like hitting a
2152      watchpoint) other than breakpoint creation.  It should be possible to
2153      clean this up and at the same time replace the random calls to
2154      breakpoint_changed with this hook, as has already been done for
2155      delete_breakpoint_hook and so on.  */
2156   if (create_breakpoint_hook)
2157     create_breakpoint_hook (b);
2158
2159   switch (b->type)
2160     {
2161     case bp_watchpoint:
2162       printf_filtered ("Watchpoint %d: ", b->number);
2163       print_expression (b->exp, gdb_stdout);
2164       break;
2165     case bp_hardware_watchpoint:
2166       printf_filtered ("Hardware watchpoint %d: ", b->number);
2167       print_expression (b->exp, gdb_stdout);
2168       break;
2169     case bp_read_watchpoint:
2170       printf_filtered ("Hardware read watchpoint %d: ", b->number);
2171       print_expression (b->exp, gdb_stdout);
2172       break;
2173     case bp_access_watchpoint:
2174       printf_filtered ("Hardware access(read/write) watchpoint %d: ",b->number);
2175       print_expression (b->exp, gdb_stdout);
2176       break;
2177     case bp_breakpoint:
2178       printf_filtered ("Breakpoint %d", b->number);
2179       say_where = 1;
2180       break;
2181     case bp_hardware_breakpoint:
2182       printf_filtered ("Hardware assisted breakpoint %d", b->number);
2183       say_where = 1;
2184       break;
2185     case bp_until:
2186     case bp_finish:
2187     case bp_longjmp:
2188     case bp_longjmp_resume:
2189     case bp_step_resume:
2190     case bp_through_sigtramp:
2191     case bp_call_dummy:
2192     case bp_watchpoint_scope:
2193       break;
2194     }
2195   if (say_where)
2196     {
2197       if (addressprint || b->source_file == NULL)
2198         {
2199           printf_filtered (" at ");
2200           print_address_numeric (b->address, 1, gdb_stdout);
2201         }
2202       if (b->source_file)
2203         printf_filtered (": file %s, line %d.",
2204                          b->source_file, b->line_number);
2205     }
2206   printf_filtered ("\n");
2207 }
2208
2209 #if 0
2210 /* Nobody calls this currently. */
2211 /* Set a breakpoint from a symtab and line.
2212    If TEMPFLAG is nonzero, it is a temporary breakpoint.
2213    ADDR_STRING is a malloc'd string holding the name of where we are
2214    setting the breakpoint.  This is used later to re-set it after the
2215    program is relinked and symbols are reloaded.
2216    Print the same confirmation messages that the breakpoint command prints.  */
2217
2218 void
2219 set_breakpoint (s, line, tempflag, addr_string)
2220      struct symtab *s;
2221      int line;
2222      int tempflag;
2223      char *addr_string;
2224 {
2225   register struct breakpoint *b;
2226   struct symtab_and_line sal;
2227   
2228   sal.symtab = s;
2229   sal.line = line;
2230   sal.pc = 0;
2231   resolve_sal_pc (&sal);                        /* Might error out */
2232   describe_other_breakpoints (sal.pc);
2233
2234   b = set_raw_breakpoint (sal);
2235   set_breakpoint_count (breakpoint_count + 1);
2236   b->number = breakpoint_count;
2237   b->type = bp_breakpoint;
2238   b->cond = 0;
2239   b->addr_string = addr_string;
2240   b->enable = enabled;
2241   b->disposition = tempflag ? delete : donttouch;
2242
2243   mention (b);
2244 }
2245 #endif /* 0 */
2246 \f
2247 /* Set a breakpoint according to ARG (function, linenum or *address)
2248    flag: first bit  : 0 non-temporary, 1 temporary.
2249          second bit : 0 normal breakpoint, 1 hardware breakpoint. */
2250
2251 static void
2252 break_command_1 (arg, flag, from_tty)
2253      char *arg;
2254      int flag, from_tty;
2255 {
2256   int tempflag, hardwareflag;
2257   struct symtabs_and_lines sals;
2258   struct symtab_and_line sal;
2259   register struct expression *cond = 0;
2260   register struct breakpoint *b;
2261
2262   /* Pointers in arg to the start, and one past the end, of the condition.  */
2263   char *cond_start = NULL;
2264   char *cond_end = NULL;
2265   /* Pointers in arg to the start, and one past the end,
2266      of the address part.  */
2267   char *addr_start = NULL;
2268   char *addr_end = NULL;
2269   struct cleanup *old_chain;
2270   struct cleanup *canonical_strings_chain = NULL;
2271   char **canonical = (char **)NULL;
2272   int i;
2273   int thread;
2274
2275   hardwareflag = flag & 2;
2276   tempflag = flag & 1;
2277
2278   sals.sals = NULL;
2279   sals.nelts = 0;
2280
2281   sal.line = sal.pc = sal.end = 0;
2282   sal.symtab = 0;
2283
2284   /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
2285
2286   if (!arg || (arg[0] == 'i' && arg[1] == 'f' 
2287                && (arg[2] == ' ' || arg[2] == '\t')))
2288     {
2289       if (default_breakpoint_valid)
2290         {
2291           sals.sals = (struct symtab_and_line *) 
2292             xmalloc (sizeof (struct symtab_and_line));
2293           sal.pc = default_breakpoint_address;
2294           sal.line = default_breakpoint_line;
2295           sal.symtab = default_breakpoint_symtab;
2296           sals.sals[0] = sal;
2297           sals.nelts = 1;
2298         }
2299       else
2300         error ("No default breakpoint address now.");
2301     }
2302   else
2303     {
2304       addr_start = arg;
2305
2306       /* Force almost all breakpoints to be in terms of the
2307          current_source_symtab (which is decode_line_1's default).  This
2308          should produce the results we want almost all of the time while
2309          leaving default_breakpoint_* alone.  */
2310       if (default_breakpoint_valid
2311           && (!current_source_symtab
2312               || (arg && (*arg == '+' || *arg == '-'))))
2313         sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
2314                               default_breakpoint_line, &canonical);
2315       else
2316         sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, &canonical);
2317
2318       addr_end = arg;
2319     }
2320   
2321   if (! sals.nelts) 
2322     return;
2323
2324   /* Make sure that all storage allocated in decode_line_1 gets freed in case
2325      the following `for' loop errors out.  */
2326   old_chain = make_cleanup (free, sals.sals);
2327   if (canonical != (char **)NULL)
2328     {
2329       make_cleanup (free, canonical);
2330       canonical_strings_chain = make_cleanup (null_cleanup, 0);
2331       for (i = 0; i < sals.nelts; i++)
2332         {
2333           if (canonical[i] != NULL)
2334             make_cleanup (free, canonical[i]);
2335         }
2336     }
2337
2338   thread = -1;                  /* No specific thread yet */
2339
2340   /* Resolve all line numbers to PC's, and verify that conditions
2341      can be parsed, before setting any breakpoints.  */
2342   for (i = 0; i < sals.nelts; i++)
2343     {
2344       char *tok, *end_tok;
2345       int toklen;
2346
2347       resolve_sal_pc (&sals.sals[i]);
2348       
2349       tok = arg;
2350
2351       while (tok && *tok)
2352         {
2353           while (*tok == ' ' || *tok == '\t')
2354             tok++;
2355
2356           end_tok = tok;
2357
2358           while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
2359             end_tok++;
2360
2361           toklen = end_tok - tok;
2362
2363           if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
2364             {
2365               tok = cond_start = end_tok + 1;
2366               cond = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
2367               cond_end = tok;
2368             }
2369           else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
2370             {
2371               char *tmptok;
2372
2373               tok = end_tok + 1;
2374               tmptok = tok;
2375               thread = strtol (tok, &tok, 0);
2376               if (tok == tmptok)
2377                 error ("Junk after thread keyword.");
2378               if (!valid_thread_id (thread))
2379                 error ("Unknown thread %d\n", thread);
2380             }
2381           else
2382             error ("Junk at end of arguments.");
2383         }
2384     }
2385   if (hardwareflag)
2386     {
2387       int i, target_resources_ok;
2388
2389       i = hw_breakpoint_used_count ();  
2390       target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
2391                 bp_hardware_breakpoint, i + sals.nelts, 0);
2392       if (target_resources_ok == 0)
2393         error ("No hardware breakpoint support in the target.");
2394       else if (target_resources_ok < 0)
2395         error ("Hardware breakpoints used exceeds limit.");
2396     }
2397
2398   /* Remove the canonical strings from the cleanup, they are needed below.  */
2399   if (canonical != (char **)NULL)
2400     discard_cleanups (canonical_strings_chain);
2401
2402   /* Now set all the breakpoints.  */
2403   for (i = 0; i < sals.nelts; i++)
2404     {
2405       sal = sals.sals[i];
2406
2407       if (from_tty)
2408         describe_other_breakpoints (sal.pc);
2409
2410       b = set_raw_breakpoint (sal);
2411       set_breakpoint_count (breakpoint_count + 1);
2412       b->number = breakpoint_count;
2413       b->type = hardwareflag ? bp_hardware_breakpoint : bp_breakpoint;
2414       b->cond = cond;
2415       b->thread = thread;
2416
2417       /* If a canonical line spec is needed use that instead of the
2418          command string.  */
2419       if (canonical != (char **)NULL && canonical[i] != NULL)
2420         b->addr_string = canonical[i];
2421       else if (addr_start)
2422         b->addr_string = savestring (addr_start, addr_end - addr_start);
2423       if (cond_start)
2424         b->cond_string = savestring (cond_start, cond_end - cond_start);
2425                                      
2426       b->enable = enabled;
2427       b->disposition = tempflag ? delete : donttouch;
2428
2429       mention (b);
2430     }
2431
2432   if (sals.nelts > 1)
2433     {
2434       printf_filtered ("Multiple breakpoints were set.\n");
2435       printf_filtered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
2436     }
2437   do_cleanups (old_chain);
2438 }
2439
2440 /* Helper function for break_command_1 and disassemble_command.  */
2441
2442 void
2443 resolve_sal_pc (sal)
2444      struct symtab_and_line *sal;
2445 {
2446   CORE_ADDR pc;
2447
2448   if (sal->pc == 0 && sal->symtab != 0)
2449     {
2450       pc = find_line_pc (sal->symtab, sal->line);
2451       if (pc == 0)
2452         error ("No line %d in file \"%s\".",
2453                sal->line, sal->symtab->filename);
2454       sal->pc = pc;
2455     }
2456 }
2457
2458 #define BP_TEMPFLAG 1
2459 #define BP_HARDWAREFLAG 2
2460 void
2461 break_command (arg, from_tty)
2462      char *arg;
2463      int from_tty;
2464 {
2465   break_command_1 (arg, 0, from_tty);
2466 }
2467
2468 static void
2469 tbreak_command (arg, from_tty)
2470      char *arg;
2471      int from_tty;
2472 {
2473   break_command_1 (arg, BP_TEMPFLAG, from_tty);
2474 }
2475
2476 static void
2477 hbreak_command (arg, from_tty)
2478      char *arg;
2479      int from_tty;
2480 {
2481   break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
2482 }
2483
2484 static void
2485 thbreak_command (arg, from_tty)
2486      char *arg;
2487      int from_tty;
2488 {
2489   break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
2490 }
2491
2492 /* ARGSUSED */
2493 /* accessflag:  0: watch write, 1: watch read, 2: watch access(read or write)
2494 */
2495 static void
2496 watch_command_1 (arg, accessflag, from_tty)
2497      char *arg;
2498      int accessflag;
2499      int from_tty;
2500 {
2501   struct breakpoint *b;
2502   struct symtab_and_line sal;
2503   struct expression *exp;
2504   struct block *exp_valid_block;
2505   struct value *val, *mark;
2506   struct frame_info *frame, *prev_frame;
2507   char *exp_start = NULL;
2508   char *exp_end = NULL;
2509   char *tok, *end_tok;
2510   int toklen;
2511   char *cond_start = NULL;
2512   char *cond_end = NULL;
2513   struct expression *cond = NULL;
2514   int i, other_type_used, target_resources_ok;
2515   enum bptype bp_type;
2516   int mem_cnt = 0;
2517
2518   sal.pc = 0;
2519   sal.symtab = NULL;
2520   sal.line = 0;
2521   
2522   /* Parse arguments.  */
2523   innermost_block = NULL;
2524   exp_start = arg;
2525   exp = parse_exp_1 (&arg, 0, 0);
2526   exp_end = arg;
2527   exp_valid_block = innermost_block;
2528   mark = value_mark ();
2529   val = evaluate_expression (exp);
2530   release_value (val);
2531   if (VALUE_LAZY (val))
2532     value_fetch_lazy (val);
2533
2534   tok = arg;
2535   while (*tok == ' ' || *tok == '\t')
2536     tok++;
2537   end_tok = tok;
2538
2539   while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
2540     end_tok++;
2541
2542   toklen = end_tok - tok;
2543   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
2544     {
2545       tok = cond_start = end_tok + 1;
2546       cond = parse_exp_1 (&tok, 0, 0);
2547       cond_end = tok;
2548     }
2549   if (*tok)
2550     error("Junk at end of command.");
2551
2552   if (accessflag == 1) bp_type = bp_read_watchpoint;
2553   else if (accessflag == 2) bp_type = bp_access_watchpoint;
2554   else bp_type = bp_hardware_watchpoint;
2555
2556   mem_cnt = can_use_hardware_watchpoint (val);
2557   if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
2558     error ("Expression cannot be implemented with read/access watchpoint.");
2559   if (mem_cnt != 0) { 
2560     i = hw_watchpoint_used_count (bp_type, &other_type_used);
2561     target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
2562                 bp_type, i + mem_cnt, other_type_used);
2563     if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
2564       error ("Target does not have this type of hardware watchpoint support.");
2565     if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
2566       error ("Target resources have been allocated for other types of watchpoints.");
2567   }
2568   
2569   /* Now set up the breakpoint.  */
2570   b = set_raw_breakpoint (sal);
2571   set_breakpoint_count (breakpoint_count + 1);
2572   b->number = breakpoint_count;
2573   b->disposition = donttouch;
2574   b->exp = exp;
2575   b->exp_valid_block = exp_valid_block;
2576   b->exp_string = savestring (exp_start, exp_end - exp_start);
2577   b->val = val;
2578   b->cond = cond;
2579   if (cond_start)
2580     b->cond_string = savestring (cond_start, cond_end - cond_start);
2581   else
2582     b->cond_string = 0;
2583          
2584   frame = block_innermost_frame (exp_valid_block);
2585   if (frame)
2586     {
2587       prev_frame = get_prev_frame (frame);
2588       b->watchpoint_frame = frame->frame;
2589     }
2590   else
2591     b->watchpoint_frame = (CORE_ADDR)0;
2592
2593   if (mem_cnt && target_resources_ok > 0)
2594     b->type = bp_type;
2595   else
2596     b->type = bp_watchpoint;
2597
2598   /* If the expression is "local", then set up a "watchpoint scope"
2599      breakpoint at the point where we've left the scope of the watchpoint
2600      expression.  */
2601   if (innermost_block)
2602     {
2603       struct breakpoint *scope_breakpoint;
2604       struct symtab_and_line scope_sal;
2605
2606       if (prev_frame)
2607         {
2608           scope_sal.pc = get_frame_pc (prev_frame);
2609           scope_sal.symtab = NULL;
2610           scope_sal.line = 0;
2611           
2612           scope_breakpoint = set_raw_breakpoint (scope_sal);
2613           set_breakpoint_count (breakpoint_count + 1);
2614           scope_breakpoint->number = breakpoint_count;
2615
2616           scope_breakpoint->type = bp_watchpoint_scope;
2617           scope_breakpoint->enable = enabled;
2618
2619           /* Automatically delete the breakpoint when it hits.  */
2620           scope_breakpoint->disposition = delete;
2621
2622           /* Only break in the proper frame (help with recursion).  */
2623           scope_breakpoint->frame = prev_frame->frame;
2624
2625           /* Set the address at which we will stop.  */
2626           scope_breakpoint->address = get_frame_pc (prev_frame);
2627
2628           /* The scope breakpoint is related to the watchpoint.  We
2629              will need to act on them together.  */
2630           b->related_breakpoint = scope_breakpoint;
2631         }
2632     }
2633   value_free_to_mark (mark);
2634   mention (b);
2635 }
2636
2637 /* Return count of locations need to be watched and can be handled
2638    in hardware.  If the watchpoint can not be handled
2639    in hardware return zero.  */
2640
2641 static int
2642 can_use_hardware_watchpoint (v)
2643      struct value *v;
2644 {
2645   int found_memory_cnt = 0;
2646         
2647   /* Make sure all the intermediate values are in memory.  Also make sure
2648      we found at least one memory expression.  Guards against watch 0x12345,
2649      which is meaningless, but could cause errors if one tries to insert a 
2650      hardware watchpoint for the constant expression.  */
2651   for ( ; v; v = v->next)
2652     {
2653       if (v->lval == lval_memory)
2654         {
2655           if (TYPE_LENGTH (VALUE_TYPE (v)) <= REGISTER_SIZE)
2656             found_memory_cnt++;
2657         }
2658       else if (v->lval != not_lval && v->modifiable == 0)
2659         return 0;
2660     }
2661
2662   /* The expression itself looks suitable for using a hardware
2663      watchpoint, but give the target machine a chance to reject it.  */
2664   return found_memory_cnt;
2665 }
2666
2667 static void watch_command (arg, from_tty)
2668      char *arg;
2669      int from_tty;
2670 {
2671   watch_command_1 (arg, 0, from_tty);
2672 }
2673
2674 static void rwatch_command (arg, from_tty)
2675      char *arg;
2676      int from_tty;
2677 {
2678   watch_command_1 (arg, 1, from_tty);
2679 }
2680
2681 static void awatch_command (arg, from_tty)
2682      char *arg;
2683      int from_tty;
2684 {
2685   watch_command_1 (arg, 2, from_tty);
2686 }
2687
2688 \f
2689 /* Helper routine for the until_command routine in infcmd.c.  Here
2690    because it uses the mechanisms of breakpoints.  */
2691
2692 /* ARGSUSED */
2693 void
2694 until_break_command (arg, from_tty)
2695      char *arg;
2696      int from_tty;
2697 {
2698   struct symtabs_and_lines sals;
2699   struct symtab_and_line sal;
2700   struct frame_info *prev_frame = get_prev_frame (selected_frame);
2701   struct breakpoint *breakpoint;
2702   struct cleanup *old_chain;
2703
2704   clear_proceed_status ();
2705
2706   /* Set a breakpoint where the user wants it and at return from
2707      this function */
2708   
2709   if (default_breakpoint_valid)
2710     sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
2711                           default_breakpoint_line, (char ***)NULL);
2712   else
2713     sals = decode_line_1 (&arg, 1, (struct symtab *)NULL, 0, (char ***)NULL);
2714   
2715   if (sals.nelts != 1)
2716     error ("Couldn't get information on specified line.");
2717   
2718   sal = sals.sals[0];
2719   free ((PTR)sals.sals);                /* malloc'd, so freed */
2720   
2721   if (*arg)
2722     error ("Junk at end of arguments.");
2723   
2724   resolve_sal_pc (&sal);
2725   
2726   breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
2727   
2728   old_chain = make_cleanup(delete_breakpoint, breakpoint);
2729
2730   /* Keep within the current frame */
2731   
2732   if (prev_frame)
2733     {
2734       sal = find_pc_line (prev_frame->pc, 0);
2735       sal.pc = prev_frame->pc;
2736       breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
2737       make_cleanup(delete_breakpoint, breakpoint);
2738     }
2739   
2740   proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
2741   do_cleanups(old_chain);
2742 }
2743 \f
2744 #if 0
2745 /* These aren't used; I don't konw what they were for.  */
2746 /* Set a breakpoint at the catch clause for NAME.  */
2747 static int
2748 catch_breakpoint (name)
2749      char *name;
2750 {
2751 }
2752
2753 static int
2754 disable_catch_breakpoint ()
2755 {
2756 }
2757
2758 static int
2759 delete_catch_breakpoint ()
2760 {
2761 }
2762
2763 static int
2764 enable_catch_breakpoint ()
2765 {
2766 }
2767 #endif /* 0 */
2768
2769 struct sal_chain
2770 {
2771   struct sal_chain *next;
2772   struct symtab_and_line sal;
2773 };
2774
2775 #if 0
2776 /* This isn't used; I don't know what it was for.  */
2777 /* For each catch clause identified in ARGS, run FUNCTION
2778    with that clause as an argument.  */
2779 static struct symtabs_and_lines
2780 map_catch_names (args, function)
2781      char *args;
2782      int (*function)();
2783 {
2784   register char *p = args;
2785   register char *p1;
2786   struct symtabs_and_lines sals;
2787 #if 0
2788   struct sal_chain *sal_chain = 0;
2789 #endif
2790
2791   if (p == 0)
2792     error_no_arg ("one or more catch names");
2793
2794   sals.nelts = 0;
2795   sals.sals = NULL;
2796
2797   while (*p)
2798     {
2799       p1 = p;
2800       /* Don't swallow conditional part.  */
2801       if (p1[0] == 'i' && p1[1] == 'f'
2802           && (p1[2] == ' ' || p1[2] == '\t'))
2803         break;
2804
2805       if (isalpha (*p1))
2806         {
2807           p1++;
2808           while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
2809             p1++;
2810         }
2811
2812       if (*p1 && *p1 != ' ' && *p1 != '\t')
2813         error ("Arguments must be catch names.");
2814
2815       *p1 = 0;
2816 #if 0
2817       if (function (p))
2818         {
2819           struct sal_chain *next
2820             = (struct sal_chain *)alloca (sizeof (struct sal_chain));
2821           next->next = sal_chain;
2822           next->sal = get_catch_sal (p);
2823           sal_chain = next;
2824           goto win;
2825         }
2826 #endif
2827       printf_unfiltered ("No catch clause for exception %s.\n", p);
2828 #if 0
2829     win:
2830 #endif
2831       p = p1;
2832       while (*p == ' ' || *p == '\t') p++;
2833     }
2834 }
2835 #endif /* 0 */
2836
2837 /* This shares a lot of code with `print_frame_label_vars' from stack.c.  */
2838
2839 static struct symtabs_and_lines
2840 get_catch_sals (this_level_only)
2841      int this_level_only;
2842 {
2843   register struct blockvector *bl;
2844   register struct block *block;
2845   int index, have_default = 0;
2846   CORE_ADDR pc;
2847   struct symtabs_and_lines sals;
2848   struct sal_chain *sal_chain = 0;
2849   char *blocks_searched;
2850
2851   /* Not sure whether an error message is always the correct response,
2852      but it's better than a core dump.  */
2853   if (selected_frame == NULL)
2854     error ("No selected frame.");
2855   block = get_frame_block (selected_frame);
2856   pc = selected_frame->pc;
2857
2858   sals.nelts = 0;
2859   sals.sals = NULL;
2860
2861   if (block == 0)
2862     error ("No symbol table info available.\n");
2863
2864   bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
2865   blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
2866   memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
2867
2868   while (block != 0)
2869     {
2870       CORE_ADDR end = BLOCK_END (block) - 4;
2871       int last_index;
2872
2873       if (bl != blockvector_for_pc (end, &index))
2874         error ("blockvector blotch");
2875       if (BLOCKVECTOR_BLOCK (bl, index) != block)
2876         error ("blockvector botch");
2877       last_index = BLOCKVECTOR_NBLOCKS (bl);
2878       index += 1;
2879
2880       /* Don't print out blocks that have gone by.  */
2881       while (index < last_index
2882              && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
2883         index++;
2884
2885       while (index < last_index
2886              && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
2887         {
2888           if (blocks_searched[index] == 0)
2889             {
2890               struct block *b = BLOCKVECTOR_BLOCK (bl, index);
2891               int nsyms;
2892               register int i;
2893               register struct symbol *sym;
2894
2895               nsyms = BLOCK_NSYMS (b);
2896
2897               for (i = 0; i < nsyms; i++)
2898                 {
2899                   sym = BLOCK_SYM (b, i);
2900                   if (STREQ (SYMBOL_NAME (sym), "default"))
2901                     {
2902                       if (have_default)
2903                         continue;
2904                       have_default = 1;
2905                     }
2906                   if (SYMBOL_CLASS (sym) == LOC_LABEL)
2907                     {
2908                       struct sal_chain *next = (struct sal_chain *)
2909                         alloca (sizeof (struct sal_chain));
2910                       next->next = sal_chain;
2911                       next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2912                       sal_chain = next;
2913                     }
2914                 }
2915               blocks_searched[index] = 1;
2916             }
2917           index++;
2918         }
2919       if (have_default)
2920         break;
2921       if (sal_chain && this_level_only)
2922         break;
2923
2924       /* After handling the function's top-level block, stop.
2925          Don't continue to its superblock, the block of
2926          per-file symbols.  */
2927       if (BLOCK_FUNCTION (block))
2928         break;
2929       block = BLOCK_SUPERBLOCK (block);
2930     }
2931
2932   if (sal_chain)
2933     {
2934       struct sal_chain *tmp_chain;
2935
2936       /* Count the number of entries.  */
2937       for (index = 0, tmp_chain = sal_chain; tmp_chain;
2938            tmp_chain = tmp_chain->next)
2939         index++;
2940
2941       sals.nelts = index;
2942       sals.sals = (struct symtab_and_line *)
2943         xmalloc (index * sizeof (struct symtab_and_line));
2944       for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
2945         sals.sals[index] = sal_chain->sal;
2946     }
2947
2948   return sals;
2949 }
2950
2951 /* Commands to deal with catching exceptions.  */
2952
2953 static void
2954 catch_command_1 (arg, tempflag, from_tty)
2955      char *arg;
2956      int tempflag;
2957      int from_tty;
2958 {
2959   /* First, translate ARG into something we can deal with in terms
2960      of breakpoints.  */
2961
2962   struct symtabs_and_lines sals;
2963   struct symtab_and_line sal;
2964   register struct expression *cond = 0;
2965   register struct breakpoint *b;
2966   char *save_arg;
2967   int i;
2968
2969   sal.line = sal.pc = sal.end = 0;
2970   sal.symtab = 0;
2971
2972   /* If no arg given, or if first arg is 'if ', all active catch clauses
2973      are breakpointed. */
2974
2975   if (!arg || (arg[0] == 'i' && arg[1] == 'f' 
2976                && (arg[2] == ' ' || arg[2] == '\t')))
2977     {
2978       /* Grab all active catch clauses.  */
2979       sals = get_catch_sals (0);
2980     }
2981   else
2982     {
2983       /* Grab selected catch clauses.  */
2984       error ("catch NAME not implemented");
2985 #if 0
2986       /* This isn't used; I don't know what it was for.  */
2987       sals = map_catch_names (arg, catch_breakpoint);
2988 #endif
2989     }
2990
2991   if (! sals.nelts) 
2992     return;
2993
2994   save_arg = arg;
2995   for (i = 0; i < sals.nelts; i++)
2996     {
2997       resolve_sal_pc (&sals.sals[i]);
2998       
2999       while (arg && *arg)
3000         {
3001           if (arg[0] == 'i' && arg[1] == 'f'
3002               && (arg[2] == ' ' || arg[2] == '\t'))
3003             cond = parse_exp_1 ((arg += 2, &arg), 
3004                                 block_for_pc (sals.sals[i].pc), 0);
3005           else
3006             error ("Junk at end of arguments.");
3007         }
3008       arg = save_arg;
3009     }
3010
3011   for (i = 0; i < sals.nelts; i++)
3012     {
3013       sal = sals.sals[i];
3014
3015       if (from_tty)
3016         describe_other_breakpoints (sal.pc);
3017
3018       b = set_raw_breakpoint (sal);
3019       set_breakpoint_count (breakpoint_count + 1);
3020       b->number = breakpoint_count;
3021       b->type = bp_breakpoint;
3022       b->cond = cond;
3023       b->enable = enabled;
3024       b->disposition = tempflag ? delete : donttouch;
3025
3026       mention (b);
3027     }
3028
3029   if (sals.nelts > 1)
3030     {
3031       printf_unfiltered ("Multiple breakpoints were set.\n");
3032       printf_unfiltered ("Use the \"delete\" command to delete unwanted breakpoints.\n");
3033     }
3034   free ((PTR)sals.sals);
3035 }
3036
3037 #if 0
3038 /* These aren't used; I don't know what they were for.  */
3039 /* Disable breakpoints on all catch clauses described in ARGS.  */
3040 static void
3041 disable_catch (args)
3042      char *args;
3043 {
3044   /* Map the disable command to catch clauses described in ARGS.  */
3045 }
3046
3047 /* Enable breakpoints on all catch clauses described in ARGS.  */
3048 static void
3049 enable_catch (args)
3050      char *args;
3051 {
3052   /* Map the disable command to catch clauses described in ARGS.  */
3053 }
3054
3055 /* Delete breakpoints on all catch clauses in the active scope.  */
3056 static void
3057 delete_catch (args)
3058      char *args;
3059 {
3060   /* Map the delete command to catch clauses described in ARGS.  */
3061 }
3062 #endif /* 0 */
3063
3064 static void
3065 catch_command (arg, from_tty)
3066      char *arg;
3067      int from_tty;
3068 {
3069   catch_command_1 (arg, 0, from_tty);
3070 }
3071 \f
3072 static void
3073 clear_command (arg, from_tty)
3074      char *arg;
3075      int from_tty;
3076 {
3077   register struct breakpoint *b, *b1;
3078   struct symtabs_and_lines sals;
3079   struct symtab_and_line sal;
3080   register struct breakpoint *found;
3081   int i;
3082
3083   if (arg)
3084     {
3085       sals = decode_line_spec (arg, 1);
3086     }
3087   else
3088     {
3089       sals.sals = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
3090       sal.line = default_breakpoint_line;
3091       sal.symtab = default_breakpoint_symtab;
3092       sal.pc = 0;
3093       if (sal.symtab == 0)
3094         error ("No source file specified.");
3095
3096       sals.sals[0] = sal;
3097       sals.nelts = 1;
3098     }
3099
3100   for (i = 0; i < sals.nelts; i++)
3101     {
3102       /* If exact pc given, clear bpts at that pc.
3103          But if sal.pc is zero, clear all bpts on specified line.  */
3104       sal = sals.sals[i];
3105       found = (struct breakpoint *) 0;
3106       while (breakpoint_chain
3107              && (sal.pc
3108                  ? breakpoint_chain->address == sal.pc
3109                  : (breakpoint_chain->source_file != NULL
3110                     && sal.symtab != NULL
3111                     && STREQ (breakpoint_chain->source_file,
3112                               sal.symtab->filename)
3113                     && breakpoint_chain->line_number == sal.line)))
3114         {
3115           b1 = breakpoint_chain;
3116           breakpoint_chain = b1->next;
3117           b1->next = found;
3118           found = b1;
3119         }
3120
3121       ALL_BREAKPOINTS (b)
3122         while (b->next
3123                && b->next->type != bp_watchpoint
3124                && b->next->type != bp_hardware_watchpoint
3125                && b->next->type != bp_read_watchpoint
3126                && b->next->type != bp_access_watchpoint
3127                && (sal.pc
3128                    ? b->next->address == sal.pc
3129                    : (b->next->source_file != NULL
3130                       && sal.symtab != NULL
3131                       && STREQ (b->next->source_file, sal.symtab->filename)
3132                       && b->next->line_number == sal.line)))
3133           {
3134             b1 = b->next;
3135             b->next = b1->next;
3136             b1->next = found;
3137             found = b1;
3138           }
3139
3140       if (found == 0)
3141         {
3142           if (arg)
3143             error ("No breakpoint at %s.", arg);
3144           else
3145             error ("No breakpoint at this line.");
3146         }
3147
3148       if (found->next) from_tty = 1; /* Always report if deleted more than one */
3149       if (from_tty) printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
3150       breakpoints_changed ();
3151       while (found)
3152         {
3153           if (from_tty) printf_unfiltered ("%d ", found->number);
3154           b1 = found->next;
3155           delete_breakpoint (found);
3156           found = b1;
3157         }
3158       if (from_tty) putchar_unfiltered ('\n');
3159     }
3160   free ((PTR)sals.sals);
3161 }
3162 \f
3163 /* Delete breakpoint in BS if they are `delete' breakpoints.
3164    This is called after any breakpoint is hit, or after errors.  */
3165
3166 void
3167 breakpoint_auto_delete (bs)
3168      bpstat bs;
3169 {
3170   for (; bs; bs = bs->next)
3171     if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete
3172         && bs->stop)
3173       delete_breakpoint (bs->breakpoint_at);
3174 }
3175
3176 /* Delete a breakpoint and clean up all traces of it in the data structures. */
3177
3178 void
3179 delete_breakpoint (bpt)
3180      struct breakpoint *bpt;
3181 {
3182   register struct breakpoint *b;
3183   register bpstat bs;
3184
3185   if (delete_breakpoint_hook)
3186     delete_breakpoint_hook (bpt);
3187
3188   if (bpt->inserted)
3189     remove_breakpoint (bpt);
3190       
3191   if (breakpoint_chain == bpt)
3192     breakpoint_chain = bpt->next;
3193
3194   ALL_BREAKPOINTS (b)
3195     if (b->next == bpt)
3196       {
3197         b->next = bpt->next;
3198         break;
3199       }
3200
3201   check_duplicates (bpt->address);
3202   /* If this breakpoint was inserted, and there is another breakpoint
3203      at the same address, we need to insert the other breakpoint.  */
3204   if (bpt->inserted
3205       && bpt->type != bp_hardware_watchpoint
3206       && bpt->type != bp_read_watchpoint
3207       && bpt->type != bp_access_watchpoint)
3208     {
3209       ALL_BREAKPOINTS (b)
3210         if (b->address == bpt->address
3211             && !b->duplicate
3212             && b->enable != disabled)
3213           {
3214             int val;
3215             val = target_insert_breakpoint (b->address, b->shadow_contents);
3216             if (val != 0)
3217               {
3218                 target_terminal_ours_for_output ();
3219                 fprintf_unfiltered (gdb_stderr, "Cannot insert breakpoint %d:\n", b->number);
3220                 memory_error (val, b->address); /* which bombs us out */
3221               }
3222             else
3223               b->inserted = 1;
3224           }
3225     }
3226
3227   free_command_lines (&bpt->commands);
3228   if (bpt->cond)
3229     free (bpt->cond);
3230   if (bpt->cond_string != NULL)
3231     free (bpt->cond_string);
3232   if (bpt->addr_string != NULL)
3233     free (bpt->addr_string);
3234   if (bpt->exp_string != NULL)
3235     free (bpt->exp_string);
3236   if (bpt->source_file != NULL)
3237     free (bpt->source_file);
3238
3239   /* Be sure no bpstat's are pointing at it after it's been freed.  */
3240   /* FIXME, how can we find all bpstat's?
3241      We just check stop_bpstat for now.  */
3242   for (bs = stop_bpstat; bs; bs = bs->next)
3243     if (bs->breakpoint_at == bpt)
3244       bs->breakpoint_at = NULL;
3245   free ((PTR)bpt);
3246 }
3247
3248 static void
3249 delete_command (arg, from_tty)
3250      char *arg;
3251      int from_tty;
3252 {
3253
3254   if (arg == 0)
3255     {
3256       /* Ask user only if there are some breakpoints to delete.  */
3257       if (!from_tty
3258           || (breakpoint_chain && query ("Delete all breakpoints? ", 0, 0)))
3259         {
3260           /* No arg; clear all breakpoints.  */
3261           while (breakpoint_chain)
3262             delete_breakpoint (breakpoint_chain);
3263         }
3264     }
3265   else
3266     map_breakpoint_numbers (arg, delete_breakpoint);
3267 }
3268
3269 /* Reset a breakpoint given it's struct breakpoint * BINT.
3270    The value we return ends up being the return value from catch_errors.
3271    Unused in this case.  */
3272
3273 static int
3274 breakpoint_re_set_one (bint)
3275      char *bint;
3276 {
3277   struct breakpoint *b = (struct breakpoint *)bint;  /* get past catch_errs */
3278   struct value *mark;
3279   int i;
3280   struct symtabs_and_lines sals;
3281   char *s;
3282   enum enable save_enable;
3283
3284   switch (b->type)
3285     {
3286     case bp_breakpoint:
3287     case bp_hardware_breakpoint:
3288       if (b->addr_string == NULL)
3289         {
3290           /* Anything without a string can't be re-set. */
3291           delete_breakpoint (b);
3292           return 0;
3293         }
3294       /* In case we have a problem, disable this breakpoint.  We'll restore
3295          its status if we succeed.  */
3296       save_enable = b->enable;
3297       b->enable = disabled;
3298
3299       set_language (b->language);
3300       input_radix = b->input_radix;
3301       s = b->addr_string;
3302       sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0, (char ***)NULL);
3303       for (i = 0; i < sals.nelts; i++)
3304         {
3305           resolve_sal_pc (&sals.sals[i]);
3306
3307           /* Reparse conditions, they might contain references to the
3308              old symtab.  */
3309           if (b->cond_string != NULL)
3310             {
3311               s = b->cond_string;
3312               if (b->cond)
3313                 free ((PTR)b->cond);
3314               b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
3315             }
3316
3317           /* We need to re-set the breakpoint if the address changes...*/
3318           if (b->address != sals.sals[i].pc
3319               /* ...or new and old breakpoints both have source files, and
3320                  the source file name or the line number changes...  */
3321               || (b->source_file != NULL
3322                   && sals.sals[i].symtab != NULL
3323                   && (!STREQ (b->source_file, sals.sals[i].symtab->filename)
3324                       || b->line_number != sals.sals[i].line)
3325                   )
3326               /* ...or we switch between having a source file and not having
3327                  one.  */
3328               || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
3329               )
3330             {
3331               if (b->source_file != NULL)
3332                 free (b->source_file);
3333               if (sals.sals[i].symtab == NULL)
3334                 b->source_file = NULL;
3335               else
3336                 b->source_file =
3337                   savestring (sals.sals[i].symtab->filename,
3338                               strlen (sals.sals[i].symtab->filename));
3339               b->line_number = sals.sals[i].line;
3340               b->address = sals.sals[i].pc;
3341           
3342               check_duplicates (b->address);
3343
3344               mention (b);
3345
3346               /* Might be better to do this just once per breakpoint_re_set,
3347                  rather than once for every breakpoint.  */
3348               breakpoints_changed ();
3349             }
3350           b->enable = save_enable;      /* Restore it, this worked. */
3351         }
3352       free ((PTR)sals.sals);
3353       break;
3354
3355     case bp_watchpoint:
3356     case bp_hardware_watchpoint:
3357     case bp_read_watchpoint:
3358     case bp_access_watchpoint:
3359       innermost_block = NULL;
3360       /* The issue arises of what context to evaluate this in.  The same
3361          one as when it was set, but what does that mean when symbols have
3362          been re-read?  We could save the filename and functionname, but
3363          if the context is more local than that, the best we could do would
3364          be something like how many levels deep and which index at that
3365          particular level, but that's going to be less stable than filenames
3366          or functionnames.  */
3367       /* So for now, just use a global context.  */
3368       b->exp = parse_expression (b->exp_string);
3369       b->exp_valid_block = innermost_block;
3370       mark = value_mark ();
3371       b->val = evaluate_expression (b->exp);
3372       release_value (b->val);
3373       if (VALUE_LAZY (b->val))
3374         value_fetch_lazy (b->val);
3375
3376       if (b->cond_string != NULL)
3377         {
3378           s = b->cond_string;
3379           b->cond = parse_exp_1 (&s, (struct block *)0, 0);
3380         }
3381       if (b->enable == enabled)
3382         mention (b);
3383       value_free_to_mark (mark);
3384       break;
3385
3386     default:
3387       printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
3388       /* fall through */
3389     case bp_until:
3390     case bp_finish:
3391     case bp_longjmp:
3392     case bp_longjmp_resume:
3393     case bp_watchpoint_scope:
3394     case bp_call_dummy:
3395       delete_breakpoint (b);
3396       break;
3397     }
3398
3399   return 0;
3400 }
3401
3402 /* Re-set all breakpoints after symbols have been re-loaded.  */
3403 void
3404 breakpoint_re_set ()
3405 {
3406   struct breakpoint *b, *temp;
3407   enum language save_language;
3408   int save_input_radix;
3409   static char message1[] = "Error in re-setting breakpoint %d:\n";
3410   char message[sizeof (message1) + 30 /* slop */];
3411   
3412   save_language = current_language->la_language;
3413   save_input_radix = input_radix;
3414   ALL_BREAKPOINTS_SAFE (b, temp)
3415     {
3416       sprintf (message, message1, b->number);   /* Format possible error msg */
3417       catch_errors (breakpoint_re_set_one, (char *) b, message,
3418                     RETURN_MASK_ALL);
3419     }
3420   set_language (save_language);
3421   input_radix = save_input_radix;
3422
3423   create_longjmp_breakpoint("longjmp");
3424   create_longjmp_breakpoint("_longjmp");
3425   create_longjmp_breakpoint("siglongjmp");
3426   create_longjmp_breakpoint(NULL);
3427
3428 #if 0
3429   /* Took this out (temporaliy at least), since it produces an extra 
3430      blank line at startup. This messes up the gdbtests. -PB */
3431   /* Blank line to finish off all those mention() messages we just printed.  */
3432   printf_filtered ("\n");
3433 #endif
3434 }
3435 \f
3436 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
3437    If from_tty is nonzero, it prints a message to that effect,
3438    which ends with a period (no newline).  */
3439
3440 void
3441 set_ignore_count (bptnum, count, from_tty)
3442      int bptnum, count, from_tty;
3443 {
3444   register struct breakpoint *b;
3445
3446   if (count < 0)
3447     count = 0;
3448
3449   ALL_BREAKPOINTS (b)
3450     if (b->number == bptnum)
3451       {
3452         b->ignore_count = count;
3453         if (!from_tty)
3454           return;
3455         else if (count == 0)
3456           printf_filtered ("Will stop next time breakpoint %d is reached.",
3457                            bptnum);
3458         else if (count == 1)
3459           printf_filtered ("Will ignore next crossing of breakpoint %d.",
3460                            bptnum);
3461         else
3462           printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
3463                   count, bptnum);
3464         breakpoints_changed ();
3465         return;
3466       }
3467
3468   error ("No breakpoint number %d.", bptnum);
3469 }
3470
3471 /* Clear the ignore counts of all breakpoints.  */
3472 void
3473 breakpoint_clear_ignore_counts ()
3474 {
3475   struct breakpoint *b;
3476
3477   ALL_BREAKPOINTS (b)
3478     b->ignore_count = 0;
3479 }
3480
3481 /* Command to set ignore-count of breakpoint N to COUNT.  */
3482
3483 static void
3484 ignore_command (args, from_tty)
3485      char *args;
3486      int from_tty;
3487 {
3488   char *p = args;
3489   register int num;
3490
3491   if (p == 0)
3492     error_no_arg ("a breakpoint number");
3493   
3494   num = get_number (&p);
3495
3496   if (*p == 0)
3497     error ("Second argument (specified ignore-count) is missing.");
3498
3499   set_ignore_count (num,
3500                     longest_to_int (value_as_long (parse_and_eval (p))),
3501                     from_tty);
3502   printf_filtered ("\n");
3503   breakpoints_changed ();
3504 }
3505 \f
3506 /* Call FUNCTION on each of the breakpoints
3507    whose numbers are given in ARGS.  */
3508
3509 static void
3510 map_breakpoint_numbers (args, function)
3511      char *args;
3512      void (*function) PARAMS ((struct breakpoint *));
3513 {
3514   register char *p = args;
3515   char *p1;
3516   register int num;
3517   register struct breakpoint *b;
3518
3519   if (p == 0)
3520     error_no_arg ("one or more breakpoint numbers");
3521
3522   while (*p)
3523     {
3524       p1 = p;
3525       
3526       num = get_number (&p1);
3527
3528       ALL_BREAKPOINTS (b)
3529         if (b->number == num)
3530           {
3531             struct breakpoint *related_breakpoint = b->related_breakpoint;
3532             function (b);
3533             if (related_breakpoint)
3534               function (related_breakpoint);
3535             goto win;
3536           }
3537       printf_unfiltered ("No breakpoint number %d.\n", num);
3538     win:
3539       p = p1;
3540     }
3541 }
3542
3543 static void
3544 enable_breakpoint (bpt)
3545      struct breakpoint *bpt;
3546 {
3547   struct frame_info *save_selected_frame = NULL;
3548   int save_selected_frame_level = -1;
3549   int target_resources_ok, other_type_used;
3550   struct value *mark;
3551   
3552   if (enable_breakpoint_hook)
3553     enable_breakpoint_hook (bpt);
3554
3555   if (bpt->type == bp_hardware_breakpoint)
3556     {
3557       int i;
3558       i = hw_breakpoint_used_count();
3559       target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT( 
3560                 bp_hardware_breakpoint, i+1, 0);
3561       if (target_resources_ok == 0)
3562         error ("No hardware breakpoint support in the target.");
3563       else if (target_resources_ok < 0)
3564         error ("Hardware breakpoints used exceeds limit.");
3565     }
3566   bpt->enable = enabled;
3567   check_duplicates (bpt->address);
3568
3569   if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint ||
3570       bpt->type == bp_read_watchpoint || bpt->type == bp_access_watchpoint)
3571     {
3572       if (bpt->exp_valid_block != NULL)
3573         {
3574           struct frame_info *fr =
3575             find_frame_addr_in_frame_chain (bpt->watchpoint_frame);
3576           if (fr == NULL)
3577             {
3578               printf_filtered ("\
3579 Cannot enable watchpoint %d because the block in which its expression\n\
3580 is valid is not currently in scope.\n", bpt->number);
3581               bpt->enable = disabled;
3582               return;
3583             }
3584
3585           save_selected_frame = selected_frame;
3586           save_selected_frame_level = selected_frame_level;
3587           select_frame (fr, -1);
3588         }
3589
3590       value_free (bpt->val);
3591       mark = value_mark ();
3592       bpt->val = evaluate_expression (bpt->exp);
3593       release_value (bpt->val);
3594       if (VALUE_LAZY (bpt->val))
3595         value_fetch_lazy (bpt->val);
3596
3597       if (bpt->type == bp_hardware_watchpoint ||
3598            bpt->type == bp_read_watchpoint ||
3599            bpt->type == bp_access_watchpoint)
3600       {
3601         int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
3602         int mem_cnt = can_use_hardware_watchpoint (bpt->val);
3603
3604         target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3605                 bpt->type, i + mem_cnt, other_type_used);
3606         /* we can consider of type is bp_hardware_watchpoint, convert to 
3607            bp_watchpoint in the following condition */
3608         if (target_resources_ok < 0)
3609           {
3610              printf_filtered("\
3611 Cannot enable watchpoint %d because target watch resources\n\
3612 have been allocated for other watchpoints.\n", bpt->number);
3613             bpt->enable = disabled;
3614             value_free_to_mark (mark);
3615             return;
3616           }
3617       }
3618
3619       if (save_selected_frame_level >= 0)
3620         select_frame (save_selected_frame, save_selected_frame_level);
3621       value_free_to_mark (mark);
3622     }
3623 }
3624
3625 /* ARGSUSED */
3626 static void
3627 enable_command (args, from_tty)
3628      char *args;
3629      int from_tty;
3630 {
3631   struct breakpoint *bpt;
3632   if (args == 0)
3633     ALL_BREAKPOINTS (bpt)
3634       switch (bpt->type)
3635         {
3636         case bp_breakpoint:
3637         case bp_hardware_breakpoint:
3638         case bp_watchpoint:
3639         case bp_hardware_watchpoint:
3640         case bp_read_watchpoint:
3641         case bp_access_watchpoint:
3642           enable_breakpoint (bpt);
3643         default:
3644           continue;
3645         }
3646   else
3647     map_breakpoint_numbers (args, enable_breakpoint);
3648 }
3649
3650 static void
3651 disable_breakpoint (bpt)
3652      struct breakpoint *bpt;
3653 {
3654   /* Never disable a watchpoint scope breakpoint; we want to
3655      hit them when we leave scope so we can delete both the
3656      watchpoint and its scope breakpoint at that time.  */
3657   if (bpt->type == bp_watchpoint_scope)
3658     return;
3659
3660   if (disable_breakpoint_hook)
3661     disable_breakpoint_hook (bpt);
3662
3663   bpt->enable = disabled;
3664
3665   check_duplicates (bpt->address);
3666 }
3667
3668 /* ARGSUSED */
3669 static void
3670 disable_command (args, from_tty)
3671      char *args;
3672      int from_tty;
3673 {
3674   register struct breakpoint *bpt;
3675   if (args == 0)
3676     ALL_BREAKPOINTS (bpt)
3677       switch (bpt->type)
3678         {
3679         case bp_breakpoint:
3680         case bp_hardware_breakpoint:
3681         case bp_watchpoint:
3682         case bp_hardware_watchpoint:
3683         case bp_read_watchpoint:
3684         case bp_access_watchpoint:
3685           disable_breakpoint (bpt);
3686         default:
3687           continue;
3688         }
3689   else
3690     map_breakpoint_numbers (args, disable_breakpoint);
3691 }
3692
3693 static void
3694 enable_once_breakpoint (bpt)
3695      struct breakpoint *bpt;
3696 {
3697   struct frame_info *save_selected_frame = NULL;
3698   int save_selected_frame_level = -1;
3699   int target_resources_ok, other_type_used;
3700   struct value *mark;
3701
3702   if (bpt->type == bp_hardware_breakpoint) 
3703     {   
3704       int i;
3705       i = hw_breakpoint_used_count();
3706       target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3707                 bp_hardware_breakpoint, i+1, 0);
3708       if (target_resources_ok == 0)
3709         error ("No hardware breakpoint support in the target.");
3710       else if (target_resources_ok < 0)
3711         error ("Hardware breakpoints used exceeds limit.");
3712     }
3713
3714   bpt->enable = enabled;
3715   bpt->disposition = disable;
3716   check_duplicates (bpt->address);
3717   breakpoints_changed ();
3718
3719   if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint ||
3720       bpt->type == bp_read_watchpoint || bpt->type == bp_access_watchpoint)
3721     {
3722       if (bpt->exp_valid_block != NULL)
3723         {
3724           struct frame_info *fr =
3725             find_frame_addr_in_frame_chain (bpt->watchpoint_frame);
3726           if (fr == NULL)
3727             {
3728               printf_filtered ("\
3729 Cannot enable watchpoint %d because the block in which its expression\n\
3730 is valid is not currently in scope.\n", bpt->number);
3731               bpt->enable = disabled;
3732               return;
3733             }
3734
3735           save_selected_frame = selected_frame;
3736           save_selected_frame_level = selected_frame_level;
3737           select_frame (fr, -1);
3738         }
3739
3740       value_free (bpt->val);
3741       mark = value_mark ();
3742       bpt->val = evaluate_expression (bpt->exp);
3743       release_value (bpt->val);
3744       if (VALUE_LAZY (bpt->val))
3745         value_fetch_lazy (bpt->val);
3746
3747       if (bpt->type == bp_hardware_watchpoint ||
3748            bpt->type == bp_read_watchpoint ||
3749            bpt->type == bp_access_watchpoint)
3750       {
3751         int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
3752         int mem_cnt = can_use_hardware_watchpoint(bpt->val);
3753         target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
3754                 bpt->type, i+mem_cnt, other_type_used);
3755         /* we can consider of type is bp_hardware_watchpoint, convert to 
3756            bp_watchpoint in the following condition */
3757         if (target_resources_ok < 0)
3758           {
3759              printf_filtered("\
3760 Cannot enable watchpoint %d because target watch resources\n\
3761 have been allocated for other watchpoints.\n", bpt->number);
3762             bpt->enable = disabled;
3763             value_free_to_mark (mark);
3764           }
3765       }
3766
3767       if (save_selected_frame_level >= 0)
3768         select_frame (save_selected_frame, save_selected_frame_level);
3769       value_free_to_mark (mark);
3770     }
3771 }
3772
3773 /* ARGSUSED */
3774 static void
3775 enable_once_command (args, from_tty)
3776      char *args;
3777      int from_tty;
3778 {
3779   map_breakpoint_numbers (args, enable_once_breakpoint);
3780 }
3781
3782 static void
3783 enable_delete_breakpoint (bpt)
3784      struct breakpoint *bpt;
3785 {
3786   bpt->enable = enabled;
3787   bpt->disposition = delete;
3788
3789   check_duplicates (bpt->address);
3790   breakpoints_changed ();
3791 }
3792
3793 /* ARGSUSED */
3794 static void
3795 enable_delete_command (args, from_tty)
3796      char *args;
3797      int from_tty;
3798 {
3799   map_breakpoint_numbers (args, enable_delete_breakpoint);
3800 }
3801 \f
3802 /* Use default_breakpoint_'s, or nothing if they aren't valid.  */
3803
3804 struct symtabs_and_lines
3805 decode_line_spec_1 (string, funfirstline)
3806      char *string;
3807      int funfirstline;
3808 {
3809   struct symtabs_and_lines sals;
3810   if (string == 0)
3811     error ("Empty line specification.");
3812   if (default_breakpoint_valid)
3813     sals = decode_line_1 (&string, funfirstline,
3814                           default_breakpoint_symtab, default_breakpoint_line,
3815                           (char ***)NULL);
3816   else
3817     sals = decode_line_1 (&string, funfirstline,
3818                           (struct symtab *)NULL, 0, (char ***)NULL);
3819   if (*string)
3820     error ("Junk at end of line specification: %s", string);
3821   return sals;
3822 }
3823 \f
3824 void
3825 _initialize_breakpoint ()
3826 {
3827   breakpoint_chain = 0;
3828   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
3829      before a breakpoint is set.  */
3830   breakpoint_count = 0;
3831
3832   add_com ("ignore", class_breakpoint, ignore_command,
3833            "Set ignore-count of breakpoint number N to COUNT.\n\
3834 Usage is `ignore N COUNT'.");
3835
3836   add_com ("commands", class_breakpoint, commands_command,
3837            "Set commands to be executed when a breakpoint is hit.\n\
3838 Give breakpoint number as argument after \"commands\".\n\
3839 With no argument, the targeted breakpoint is the last one set.\n\
3840 The commands themselves follow starting on the next line.\n\
3841 Type a line containing \"end\" to indicate the end of them.\n\
3842 Give \"silent\" as the first line to make the breakpoint silent;\n\
3843 then no output is printed when it is hit, except what the commands print.");
3844
3845   add_com ("condition", class_breakpoint, condition_command,
3846            "Specify breakpoint number N to break only if COND is true.\n\
3847 Usage is `condition N COND', where N is an integer and COND is an\n\
3848 expression to be evaluated whenever breakpoint N is reached.  ");
3849
3850   add_com ("tbreak", class_breakpoint, tbreak_command,
3851            "Set a temporary breakpoint.  Args like \"break\" command.\n\
3852 Like \"break\" except the breakpoint is only temporary,\n\
3853 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
3854 by using \"enable delete\" on the breakpoint number.");
3855
3856   add_com ("hbreak", class_breakpoint, hbreak_command,
3857            "Set a hardware assisted  breakpoint. Args like \"break\" command.\n\
3858 Like \"break\" except the breakpoint requires hardware support,\n\
3859 some target hardware may not have this support.");
3860
3861   add_com ("thbreak", class_breakpoint, thbreak_command,
3862            "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
3863 Like \"hbreak\" except the breakpoint is only temporary,\n\
3864 so it will be deleted when hit.");
3865
3866   add_prefix_cmd ("enable", class_breakpoint, enable_command,
3867                   "Enable some breakpoints.\n\
3868 Give breakpoint numbers (separated by spaces) as arguments.\n\
3869 With no subcommand, breakpoints are enabled until you command otherwise.\n\
3870 This is used to cancel the effect of the \"disable\" command.\n\
3871 With a subcommand you can enable temporarily.",
3872                   &enablelist, "enable ", 1, &cmdlist);
3873
3874   add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
3875                   "Enable some breakpoints.\n\
3876 Give breakpoint numbers (separated by spaces) as arguments.\n\
3877 This is used to cancel the effect of the \"disable\" command.\n\
3878 May be abbreviated to simply \"enable\".\n",
3879                   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
3880
3881   add_cmd ("once", no_class, enable_once_command,
3882            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
3883 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
3884            &enablebreaklist);
3885
3886   add_cmd ("delete", no_class, enable_delete_command,
3887            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
3888 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3889            &enablebreaklist);
3890
3891   add_cmd ("delete", no_class, enable_delete_command,
3892            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
3893 If a breakpoint is hit while enabled in this fashion, it is deleted.",
3894            &enablelist);
3895
3896   add_cmd ("once", no_class, enable_once_command,
3897            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
3898 If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
3899            &enablelist);
3900
3901   add_prefix_cmd ("disable", class_breakpoint, disable_command,
3902            "Disable some breakpoints.\n\
3903 Arguments are breakpoint numbers with spaces in between.\n\
3904 To disable all breakpoints, give no argument.\n\
3905 A disabled breakpoint is not forgotten, but has no effect until reenabled.",
3906                   &disablelist, "disable ", 1, &cmdlist);
3907   add_com_alias ("dis", "disable", class_breakpoint, 1);
3908   add_com_alias ("disa", "disable", class_breakpoint, 1);
3909
3910   add_cmd ("breakpoints", class_alias, disable_command,
3911            "Disable some breakpoints.\n\
3912 Arguments are breakpoint numbers with spaces in between.\n\
3913 To disable all breakpoints, give no argument.\n\
3914 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
3915 This command may be abbreviated \"disable\".",
3916            &disablelist);
3917
3918   add_prefix_cmd ("delete", class_breakpoint, delete_command,
3919            "Delete some breakpoints or auto-display expressions.\n\
3920 Arguments are breakpoint numbers with spaces in between.\n\
3921 To delete all breakpoints, give no argument.\n\
3922 \n\
3923 Also a prefix command for deletion of other GDB objects.\n\
3924 The \"unset\" command is also an alias for \"delete\".",
3925                   &deletelist, "delete ", 1, &cmdlist);
3926   add_com_alias ("d", "delete", class_breakpoint, 1);
3927
3928   add_cmd ("breakpoints", class_alias, delete_command,
3929            "Delete some breakpoints or auto-display expressions.\n\
3930 Arguments are breakpoint numbers with spaces in between.\n\
3931 To delete all breakpoints, give no argument.\n\
3932 This command may be abbreviated \"delete\".",
3933            &deletelist);
3934
3935   add_com ("clear", class_breakpoint, clear_command,
3936            concat ("Clear breakpoint at specified line or function.\n\
3937 Argument may be line number, function name, or \"*\" and an address.\n\
3938 If line number is specified, all breakpoints in that line are cleared.\n\
3939 If function is specified, breakpoints at beginning of function are cleared.\n\
3940 If an address is specified, breakpoints at that address are cleared.\n\n",
3941 "With no argument, clears all breakpoints in the line that the selected frame\n\
3942 is executing in.\n\
3943 \n\
3944 See also the \"delete\" command which clears breakpoints by number.", NULL));
3945
3946   add_com ("break", class_breakpoint, break_command,
3947            concat ("Set breakpoint at specified line or function.\n\
3948 Argument may be line number, function name, or \"*\" and an address.\n\
3949 If line number is specified, break at start of code for that line.\n\
3950 If function is specified, break at start of code for that function.\n\
3951 If an address is specified, break at that exact address.\n",
3952 "With no arg, uses current execution address of selected stack frame.\n\
3953 This is useful for breaking on return to a stack frame.\n\
3954 \n\
3955 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
3956 \n\
3957 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
3958   add_com_alias ("b", "break", class_run, 1);
3959   add_com_alias ("br", "break", class_run, 1);
3960   add_com_alias ("bre", "break", class_run, 1);
3961   add_com_alias ("brea", "break", class_run, 1);
3962
3963   add_info ("breakpoints", breakpoints_info,
3964             concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
3965 The \"Type\" column indicates one of:\n\
3966 \tbreakpoint     - normal breakpoint\n\
3967 \twatchpoint     - watchpoint\n\
3968 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3969 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
3970 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
3971 address and file/line number respectively.\n\n",
3972 "Convenience variable \"$_\" and default examine address for \"x\"\n\
3973 are set to the address of the last breakpoint listed.\n\n\
3974 Convenience variable \"$bpnum\" contains the number of the last\n\
3975 breakpoint set.", NULL));
3976
3977 #if MAINTENANCE_CMDS
3978
3979   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
3980             concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
3981 The \"Type\" column indicates one of:\n\
3982 \tbreakpoint     - normal breakpoint\n\
3983 \twatchpoint     - watchpoint\n\
3984 \tlongjmp        - internal breakpoint used to step through longjmp()\n\
3985 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
3986 \tuntil          - internal breakpoint used by the \"until\" command\n\
3987 \tfinish         - internal breakpoint used by the \"finish\" command\n",
3988 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
3989 the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
3990 breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
3991 address and file/line number respectively.\n\n",
3992 "Convenience variable \"$_\" and default examine address for \"x\"\n\
3993 are set to the address of the last breakpoint listed.\n\n\
3994 Convenience variable \"$bpnum\" contains the number of the last\n\
3995 breakpoint set.", NULL),
3996            &maintenanceinfolist);
3997
3998 #endif  /* MAINTENANCE_CMDS */
3999
4000   add_com ("catch", class_breakpoint, catch_command,
4001          "Set breakpoints to catch exceptions that are raised.\n\
4002 Argument may be a single exception to catch, multiple exceptions\n\
4003 to catch, or the default exception \"default\".  If no arguments\n\
4004 are given, breakpoints are set at all exception handlers catch clauses\n\
4005 within the current scope.\n\
4006 \n\
4007 A condition specified for the catch applies to all breakpoints set\n\
4008 with this command\n\
4009 \n\
4010 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
4011
4012   add_com ("watch", class_breakpoint, watch_command,
4013            "Set a watchpoint for an expression.\n\
4014 A watchpoint stops execution of your program whenever the value of\n\
4015 an expression changes.");
4016
4017   add_com ("rwatch", class_breakpoint, rwatch_command,
4018            "Set a read watchpoint for an expression.\n\
4019 A watchpoint stops execution of your program whenever the value of\n\
4020 an expression is read.");
4021
4022   add_com ("awatch", class_breakpoint, awatch_command,
4023            "Set a watchpoint for an expression.\n\
4024 A watchpoint stops execution of your program whenever the value of\n\
4025 an expression is either read or written.");
4026
4027   add_info ("watchpoints", breakpoints_info,
4028             "Synonym for ``info breakpoints''.");
4029
4030 }
4031
4032 /* OK, when we call objfile_relocate, we need to relocate breakpoints
4033    too.  breakpoint_re_set is not a good choice--for example, if
4034    addr_string contains just a line number without a file name the
4035    breakpoint might get set in a different file.  In general, there is
4036    no need to go all the way back to the user's string (though this might
4037    work if some effort were made to canonicalize it), since symtabs and
4038    everything except addresses are still valid.
4039
4040    Probably the best way to solve this is to have each breakpoint save
4041    the objfile and the section number that was used to set it (if set
4042    by "*addr", probably it is best to use find_pc_line to get a symtab
4043    and use the objfile and block_line_section for that symtab).  Then
4044    objfile_relocate can call fixup_breakpoints with the objfile and
4045    the new_offsets, and it can relocate only the appropriate breakpoints.  */
4046
4047 #ifdef IBM6000_TARGET
4048 /* But for now, just kludge it based on the concept that before an
4049    objfile is relocated the breakpoint is below 0x10000000, and afterwards
4050    it is higher, so that way we only relocate each breakpoint once.  */
4051
4052 void
4053 fixup_breakpoints (low, high, delta)
4054   CORE_ADDR low;
4055   CORE_ADDR high;
4056   CORE_ADDR delta;
4057 {
4058   struct breakpoint *b;
4059
4060   ALL_BREAKPOINTS (b)
4061     {
4062      if (b->address >= low && b->address <= high)
4063        b->address += delta;
4064     }
4065 }
4066 #endif