* infrun.c, infcmd.c, breakpoint.c, main.c, symfile.c,

breakpoint.h, tm-sun4os4.h, tm-sparc.h, sparc-tdep.c, tm-mips.h,
mips-tdep.h, tm-sun3.h, tm-68k.h, m68k-tdep.h:  Add support for
stepping (and nexting) through longjmp().  Also, cleanup
breakpoint handling quite a bit by creating explicit breakpoint
types instead of using magic breakpoint numbers.
Makefile.in:  Update version to 4.4.3

1 files changed, 432 insertions, 237 deletions

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index f6b136f..61a7a9f 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -1,5 +1,5 @@
 /* Everything about breakpoints, for GDB.
-   Copyright (C) 1986, 1987, 1989, 1990 Free Software Foundation, Inc.
+   Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -20,10 +20,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include <stdio.h>
 #include <ctype.h>
 #include "defs.h"
-#include "param.h"
 #include "symtab.h"
 #include "frame.h"
 #include "breakpoint.h"
+#include "gdbtypes.h"
 #include "expression.h"
 #include "gdbcore.h"
 #include "gdbcmd.h"
@@ -35,85 +35,114 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "language.h"
 #include <string.h>
 
+/* local function prototypes */
+
+static void
+catch_command_1 PARAMS ((char *, int, int));
+
+static void
+enable_delete_command PARAMS ((char *, int));
+
+static void
+enable_delete_breakpoint PARAMS ((struct breakpoint *));
+
+static void
+enable_once_command PARAMS ((char *, int));
+
+static void
+enable_once_breakpoint PARAMS ((struct breakpoint *));
+
+static void
+disable_command PARAMS ((char *, int));
+
+static void
+disable_breakpoint PARAMS ((struct breakpoint *));
+
+static void
+enable_command PARAMS ((char *, int));
+
+static void
+enable_breakpoint PARAMS ((struct breakpoint *));
+
+static void
+map_breakpoint_numbers PARAMS ((char *,	void (*)(struct breakpoint *)));
+
+static void
+ignore_command PARAMS ((char *, int));
+
+static int
+breakpoint_re_set_one PARAMS ((char *));
+
+static void
+delete_command PARAMS ((char *, int));
+
+static void
+clear_command PARAMS ((char *, int));
+
+static void
+catch_command PARAMS ((char *, int));
+
+static struct symtabs_and_lines
+get_catch_sals PARAMS ((int));
+
+static void
+watch_command PARAMS ((char *, int));
+
+static void
+tbreak_command PARAMS ((char *, int));
+
+static void
+break_command_1 PARAMS ((char *, int, int));
+
+static void
+mention PARAMS ((struct breakpoint *));
+
+static struct breakpoint *
+set_raw_breakpoint PARAMS ((struct symtab_and_line));
+
+static void
+check_duplicates PARAMS ((CORE_ADDR));
+
+static void
+describe_other_breakpoints PARAMS ((CORE_ADDR));
+
+static void
+watchpoints_info PARAMS ((char *, int));
+
+static void
+breakpoints_info PARAMS ((char *, int));
+
+static void
+breakpoint_1 PARAMS ((int, int));
+
+static bpstat
+bpstat_alloc PARAMS ((struct breakpoint *, bpstat));
+
+static int
+breakpoint_cond_eval PARAMS ((char *));
+
+static void
+cleanup_executing_breakpoints PARAMS ((int));
+
+static void
+commands_command PARAMS ((char *, int));
+
+static void
+condition_command PARAMS ((char *, int));
+
+static int
+get_number PARAMS ((char **));
+
+static void
+set_breakpoint_count PARAMS ((int));
+
+
 extern int addressprint;		/* Print machine addresses? */
 extern int demangle;			/* Print de-mangled symbol names? */
 
-extern int catch_errors ();
-extern void set_next_address ();	/* ...for x/ command */
-
 /* Are we executing breakpoint commands?  */
 static int executing_breakpoint_commands;
 
-/* States of enablement of breakpoint.
-   `temporary' means disable when hit.
-   `delete' means delete when hit.  */
-
-enum enable { disabled, enabled, temporary, delete};
-
-/* Not that the ->silent field is not currently used by any commands
-   (though the code is in there if it was to be, and set_raw_breakpoint
-   does set it to 0).  I implemented it because I thought it would be
-   useful for a hack I had to put in; I'm going to leave it in because
-   I can see how there might be times when it would indeed be useful */
-
-/* This is for a breakpoint or a watchpoint.  */
-
-struct breakpoint
-{
-  struct breakpoint *next;
-  /* Number assigned to distinguish breakpoints.  */
-  int number;
-  /* Address to break at, or NULL if not a breakpoint.  */
-  CORE_ADDR address;
-  /* Line number of this address.  Redundant.  Only matters if address
-     is non-NULL.  */
-  int line_number;
-  /* Symtab of file of this address.  Redundant.  Only matters if address
-     is non-NULL.  */
-  struct symtab *symtab;
-  /* Zero means disabled; remember the info but don't break here.  */
-  enum enable enable;
-  /* Non-zero means a silent breakpoint (don't print frame info
-     if we stop here). */
-  unsigned char silent;
-  /* Number of stops at this breakpoint that should
-     be continued automatically before really stopping.  */
-  int ignore_count;
-  /* "Real" contents of byte where breakpoint has been inserted.
-     Valid only when breakpoints are in the program.  Under the complete
-     control of the target insert_breakpoint and remove_breakpoint routines.
-     No other code should assume anything about the value(s) here.  */
-  char shadow_contents[BREAKPOINT_MAX];
-  /* Nonzero if this breakpoint is now inserted.  Only matters if address
-     is non-NULL.  */
-  char inserted;
-  /* Nonzero if this is not the first breakpoint in the list
-     for the given address.  Only matters if address is non-NULL.  */
-  char duplicate;
-  /* Chain of command lines to execute when this breakpoint is hit.  */
-  struct command_line *commands;
-  /* Stack depth (address of frame).  If nonzero, break only if fp
-     equals this.  */
-  FRAME_ADDR frame;
-  /* Conditional.  Break only if this expression's value is nonzero.  */
-  struct expression *cond;
-
-  /* String we used to set the breakpoint (malloc'd).  Only matters if
-     address is non-NULL.  */
-  char *addr_string;
-  /* String form of the breakpoint condition (malloc'd), or NULL if there
-     is no condition.  */
-  char *cond_string;
-
-  /* The expression we are watching, or NULL if not a watchpoint.  */
-  struct expression *exp;
-  /* The largest block within which it is valid, or NULL if it is
-     valid anywhere (e.g. consists just of global symbols).  */
-  struct block *exp_valid_block;
-  /* Value of the watchpoint the last time we checked it.  */
-  value val;
-};
-
 #define ALL_BREAKPOINTS(b)  for (b = breakpoint_chain; b; b = b->next)
 
 /* Chain of all breakpoints defined.  */
@@ -146,9 +175,6 @@ CORE_ADDR default_breakpoint_address;
 struct symtab *default_breakpoint_symtab;
 int default_breakpoint_line;
 
-static void delete_breakpoint ();
-void breakpoint_auto_delete ();
-
 /* Flag indicating extra verbosity for xgdb.  */
 extern int xgdb_verbose;
 
@@ -299,7 +325,13 @@ End with a line saying just \"end\".\n", bnum);
 extern int memory_breakpoint_size; /* from mem-break.c */
 
 /* Like target_read_memory() but if breakpoints are inserted, return
-   the shadow contents instead of the breakpoints themselves.  */
+   the shadow contents instead of the breakpoints themselves.
+
+   Read "memory data" from whatever target or inferior we have. 
+   Returns zero if successful, errno value if not.  EIO is used
+   for address out of bounds.  If breakpoints are inserted, returns
+   shadow contents, not the breakpoints themselves.  From breakpoint.c.  */
+
 int
 read_memory_nobpt (memaddr, myaddr, len)
      CORE_ADDR memaddr;
@@ -315,7 +347,7 @@ read_memory_nobpt (memaddr, myaddr, len)
   
   ALL_BREAKPOINTS (b)
     {
-      if (b->address == NULL || !b->inserted)
+      if (b->type == bp_watchpoint || !b->inserted)
 	continue;
       else if (b->address + memory_breakpoint_size <= memaddr)
 	/* The breakpoint is entirely before the chunk of memory
@@ -392,7 +424,7 @@ insert_breakpoints ()
   int disabled_breaks = 0;
 
   ALL_BREAKPOINTS (b)
-    if (b->address != NULL
+    if (b->type != bp_watchpoint
 	&& b->enable != disabled
 	&& ! b->inserted
 	&& ! b->duplicate)
@@ -445,7 +477,7 @@ remove_breakpoints ()
 #endif /* BREAKPOINT_DEBUG */
 
   ALL_BREAKPOINTS (b)
-    if (b->address != NULL && b->inserted)
+    if (b->type != bp_watchpoint && b->inserted)
       {
 	val = target_remove_breakpoint(b->address, b->shadow_contents);
 	if (val)
@@ -495,6 +527,10 @@ breakpoint_here_p (pc)
 
 /* bpstat stuff.  External routines' interfaces are documented
    in breakpoint.h.  */
+
+/* Clear a bpstat so that it says we are not at any breakpoint.
+   Also free any storage that is part of a bpstat.  */
+
 void
 bpstat_clear (bsp)
      bpstat *bsp;
@@ -516,6 +552,9 @@ bpstat_clear (bsp)
   *bsp = NULL;
 }
 
+/* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
+   is part of the bpstat is copied as well.  */
+
 bpstat
 bpstat_copy (bs)
      bpstat bs;
@@ -542,6 +581,27 @@ bpstat_copy (bs)
   return retval;
 }
 
+/* Find the bpstat associated with this breakpoint */
+
+bpstat
+bpstat_find_breakpoint(bsp, breakpoint)
+     bpstat bsp;
+     struct breakpoint *breakpoint;
+{
+  if (bsp == NULL) return NULL;
+
+  for (;bsp != NULL; bsp = bsp->next) {
+    if (bsp->breakpoint_at == breakpoint) return bsp;
+  }
+  return NULL;
+}
+
+/* Return the breakpoint number of the first breakpoint we are stopped
+   at.  *BSP upon return is a bpstat which points to the remaining
+   breakpoints stopped at (but which is not guaranteed to be good for
+   anything but further calls to bpstat_num).
+   Return 0 if passed a bpstat which does not indicate any breakpoints.  */
+
 int
 bpstat_num (bsp)
      bpstat *bsp;
@@ -561,6 +621,8 @@ bpstat_num (bsp)
     }
 }
 
+/* Modify BS so that the actions will not be performed.  */
+
 void
 bpstat_clear_actions (bs)
      bpstat bs;
@@ -589,6 +651,7 @@ cleanup_executing_breakpoints (ignore)
    location.  Any of these commands could cause the process to proceed
    beyond this point, etc.  We look out for such changes by checking
    the global "breakpoint_proceeded" after each command.  */
+
 void
 bpstat_do_actions (bsp)
      bpstat *bsp;
@@ -618,19 +681,25 @@ top:
 	    goto top;
 	}
     }
-  clear_momentary_breakpoints ();
 
   executing_breakpoint_commands = 0;
   discard_cleanups (old_chain);
 }
 
+/* Print a message indicating what happened.  Returns nonzero to
+   say that only the source line should be printed after this (zero
+   return means print the frame as well as the source line).  */
+
 int
 bpstat_print (bs)
      bpstat bs;
 {
   /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
      which has since been deleted.  */
-  if (bs == NULL || bs->breakpoint_at == NULL)
+  if (bs == NULL
+      || bs->breakpoint_at == NULL
+      || (bs->breakpoint_at->type != bp_breakpoint
+	  && bs->breakpoint_at->type != bp_watchpoint))
     return 0;
   
   /* If bpstat_stop_status says don't print, OK, we won't.  An example
@@ -643,7 +712,7 @@ bpstat_print (bs)
   if (!bs->print)
     return 0;
 
-  if (bs->breakpoint_at->address != NULL)
+  if (bs->breakpoint_at->type == bp_breakpoint)
     {
       /* I think the user probably only wants to see one breakpoint
 	 number, not all of them.  */
@@ -703,7 +772,7 @@ bpstat_alloc (b, cbs)
   bs->breakpoint_at = b;
   /* If the condition is false, etc., don't do the commands.  */
   bs->commands = NULL;
-  bs->momentary = b->number == -3;
+  bs->momentary = b->disposition == delete;
   bs->old_val = NULL;
   return bs;
 }
@@ -755,15 +824,18 @@ bpstat_stop_status (pc, frame_address)
 
       if (b->enable == disabled)
 	continue;
-      if (b->address != NULL && b->address != bp_addr)
+
+      if (b->type != bp_watchpoint && b->address != bp_addr)
 	continue;
 
+      /* Come here if it's a watchpoint, or if the break address matches */
+
       bs = bpstat_alloc (b, bs);	/* Alloc a bpstat to explain stop */
 
       this_bp_stop = 1;
       this_bp_print = 1;
 
-      if (b->exp != NULL)		/* Watchpoint */
+      if (b->type == bp_watchpoint)
 	{
 	  int within_current_scope;
 	  if (b->exp_valid_block != NULL)
@@ -849,7 +921,7 @@ which its expression is valid.\n", b->number);
 	  else
 	    {
 	      /* We will stop here */
-	      if (b->enable == temporary)
+	      if (b->disposition == disable)
 		b->enable = disabled;
 	      bs->commands = b->commands;
 	      if (b->silent)
@@ -896,12 +968,16 @@ which its expression is valid.\n", b->number);
   return bs;
 }
 
+/* Nonzero if we should step constantly (e.g. watchpoints on machines
+   without hardware support).  This isn't related to a specific bpstat,
+   just to things like whether watchpoints are set.  */
+
 int 
 bpstat_should_step ()
 {
   struct breakpoint *b;
   ALL_BREAKPOINTS (b)
-    if (b->enable != disabled && b->exp != NULL)
+    if (b->enable == enabled && b->type == bp_watchpoint)
       return 1;
   return 0;
 }
@@ -911,50 +987,47 @@ bpstat_should_step ()
    is nonzero, process only watchpoints.  */
 
 static void
-breakpoint_1 (bnum, watchpoints)
+breakpoint_1 (bnum, type)
      int bnum;
-     int watchpoints;
+     enum bptype type;
 {
   register struct breakpoint *b;
   register struct command_line *l;
   register struct symbol *sym;
   CORE_ADDR last_addr = (CORE_ADDR)-1;
-  int header_printed = 0;
+  int found_a_breakpoint = 0;
+  static char *bptypes[] = {"breakpoint", "until", "finish", "watchpoint",
+			      "longjmp", "longjmp resume"};
+  static char *bpdisps[] = {"del", "dis", ""};
+  static char bpenables[] = "ny";
+
+  if (!breakpoint_chain)
+    {
+      printf_filtered ("No breakpoints or watchpoints.\n");
+      return;
+    }
   
   ALL_BREAKPOINTS (b)
-    if (bnum == -1 || bnum == b->number)
+    if (bnum == -1
+	|| bnum == b->number)
       {
-	if (b->address == NULL && !watchpoints)
+	if (!found_a_breakpoint++)
+	  printf_filtered ("Num Type       Disp Enb %sWhat\n",
+			   addressprint ? "Address    " : "");
+
+	printf_filtered ("%-3d %-10s %-4s %-3c ",
+			 b->number,
+			 bptypes[b->type],
+			 bpdisps[b->disposition],
+			 bpenables[b->enable]);
+	switch (b->type)
 	  {
-	    if (bnum == -1)
-	      continue;
-	    error ("That is a watchpoint, not a breakpoint.");
-	  }
-	if (b->address != NULL && watchpoints)
-	  {
-	    if (bnum == -1)
-	      continue;
-	    error ("That is a breakpoint, not a watchpoint.");
-	  }
-
-	if (!header_printed)
-	  {
-	    if (watchpoints)
-	      printf_filtered ("    Enb   Expression\n");
-	    else if (addressprint)
-	      printf_filtered ("    Enb   Address    Where\n");
-	    else
-	      printf_filtered ("    Enb   Where\n");
-	    header_printed = 1;
-	  }
-
-	printf_filtered ("#%-3d %c ", b->number, "nyod"[(int) b->enable]);
-	if (b->address == NULL) {
-	  printf_filtered (" ");
-	  print_expression (b->exp, stdout);
-	} else {
+	  case bp_watchpoint:
+	    print_expression (b->exp, stdout);
+	    break;
+	  case bp_breakpoint:
 	    if (addressprint)
-	      printf_filtered (" %s ", local_hex_string_custom(b->address, "08"));
+	      printf_filtered ("%s ", local_hex_string_custom(b->address, "08"));
 
 	    last_addr = b->address;
 	    if (b->symtab)
@@ -962,7 +1035,7 @@ breakpoint_1 (bnum, watchpoints)
 		sym = find_pc_function (b->address);
 		if (sym)
 		  {
-		    fputs_filtered (" in ", stdout);
+		    fputs_filtered ("in ", stdout);
 		    fputs_demangled (SYMBOL_NAME (sym), stdout, 1);
 		    fputs_filtered (" at ", stdout);
 		  }
@@ -996,19 +1069,14 @@ breakpoint_1 (bnum, watchpoints)
 	    }
       }
 
-  if (!header_printed)
-    {
-      char *which = watchpoints ? "watch" : "break";
-      if (bnum == -1)
-	printf_filtered ("No %spoints.\n", which);
-      else
-	printf_filtered ("No %spoint numbered %d.\n", which, bnum);
-    }
-
-  /* Compare against (CORE_ADDR)-1 in case some compiler decides
-     that a comparison of an unsigned with -1 is always false.  */
-  if (last_addr != (CORE_ADDR)-1)
-    set_next_address (last_addr);
+  if (!found_a_breakpoint
+      && bnum != -1)
+    printf_filtered ("No breakpoint or watchpoint number %d.\n", bnum);
+  else
+    /* Compare against (CORE_ADDR)-1 in case some compiler decides
+       that a comparison of an unsigned with -1 is always false.  */
+    if (last_addr != (CORE_ADDR)-1)
+      set_next_address (last_addr);
 }
 
 /* ARGSUSED */
@@ -1022,7 +1090,7 @@ breakpoints_info (bnum_exp, from_tty)
   if (bnum_exp)
     bnum = parse_and_eval_address (bnum_exp);
 
-  breakpoint_1 (bnum, 0);
+  breakpoint_1 (bnum, bp_breakpoint);
 }
 
 /* ARGSUSED */
@@ -1036,7 +1104,7 @@ watchpoints_info (bnum_exp, from_tty)
   if (bnum_exp)
     bnum = parse_and_eval_address (bnum_exp);
 
-  breakpoint_1 (bnum, 1);
+  breakpoint_1 (bnum, bp_watchpoint);
 }
 
 /* Print a message describing any breakpoints set at PC.  */
@@ -1094,7 +1162,7 @@ check_duplicates (address)
   register struct breakpoint *b;
   register int count = 0;
 
-  if (address == NULL)		/* Watchpoints are uninteresting */
+  if (address == 0)		/* Watchpoints are uninteresting */
     return;
 
   ALL_BREAKPOINTS (b)
@@ -1131,7 +1199,7 @@ set_raw_breakpoint (sal)
   b->silent = 0;
   b->ignore_count = 0;
   b->commands = NULL;
-  b->frame = NULL;
+  b->frame = 0;
 
   /* Add this breakpoint to the end of the chain
      so that a list of breakpoints will come out in order
@@ -1152,46 +1220,171 @@ set_raw_breakpoint (sal)
   return b;
 }
 
+struct breakpoint *longjmp_breakpoint = NULL;
+struct breakpoint *_longjmp_breakpoint = NULL;
+struct breakpoint *siglongjmp_breakpoint = NULL;
+struct breakpoint *longjmp_resume_breakpoint = NULL;
+
+static void
+create_longjmp_breakpoint_1(func_name, bpt)
+     char *func_name;
+     struct breakpoint **bpt;
+{
+  int i;
+  struct symtab_and_line sal;
+  struct breakpoint *b;
+
+  if (*bpt != NULL)
+    {
+      delete_breakpoint(*bpt);
+      *bpt = NULL;
+    }
+
+  if (func_name != NULL)
+    {
+      struct minimal_symbol *m;
+
+      m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
+      if (m)
+	sal.pc = m->address;
+      else
+	return;
+    }
+  else
+    sal.pc = 0;
+
+  sal.symtab = NULL;
+  sal.line = 0;
+  if (*bpt != NULL)
+    b = *bpt;
+  else
+    b = set_raw_breakpoint(sal);
+
+  if (!b) return;
+
+  b->type = bp_longjmp;
+  b->disposition = donttouch;
+  b->enable = disabled;
+  b->silent = 1;
+  *bpt = b;
+}
+
+/* Call this routine each time we read a new executable or symbol table
+   file.  */
+
+#ifdef GET_LONGJMP_TARGET
+void
+create_longjmp_breakpoint()
+{
+  create_longjmp_breakpoint_1("longjmp", &longjmp_breakpoint);
+  create_longjmp_breakpoint_1("_longjmp", &_longjmp_breakpoint);
+  create_longjmp_breakpoint_1("siglongjmp", &siglongjmp_breakpoint);
+
+  if ((longjmp_breakpoint || _longjmp_breakpoint || siglongjmp_breakpoint)
+      && !longjmp_resume_breakpoint)
+    {
+      create_longjmp_breakpoint_1(NULL, &longjmp_resume_breakpoint);
+      if (longjmp_resume_breakpoint)
+	longjmp_resume_breakpoint->type = bp_longjmp_resume;
+    }
+}
+#else
+void
+create_longjmp_breakpoint()
+{
+}
+#endif
+
+/* Call this routine when stepping and nexting to enable a breakpoint if we do
+   a longjmp().  When we hit that breakpoint, call
+   set_longjmp_resume_breakpoint() to figure out where we are going. */
+
+void
+enable_longjmp_breakpoint()
+{
+  if (longjmp_breakpoint)
+    longjmp_breakpoint->enable = enabled;
+  if (_longjmp_breakpoint)
+    _longjmp_breakpoint->enable = enabled;
+  if (siglongjmp_breakpoint)
+    siglongjmp_breakpoint->enable = enabled;
+}
+
+void
+disable_longjmp_breakpoint()
+{
+  if (longjmp_breakpoint)
+    longjmp_breakpoint->enable = disabled;
+  if (_longjmp_breakpoint)
+    _longjmp_breakpoint->enable = disabled;
+  if (siglongjmp_breakpoint)
+    siglongjmp_breakpoint->enable = disabled;
+  if (longjmp_resume_breakpoint)
+    longjmp_resume_breakpoint->enable = disabled;
+}
+
+/* Call this after hitting the longjmp() breakpoint.  Use this to set a new
+   breakpoint at the target of the jmp_buf.
+*/
+
+void
+set_longjmp_resume_breakpoint(pc, frame)
+     CORE_ADDR pc;
+     FRAME frame;
+{
+  longjmp_resume_breakpoint->address = pc;
+  longjmp_resume_breakpoint->enable = enabled;
+  if (frame != NULL)
+    longjmp_resume_breakpoint->frame = FRAME_FP(frame);
+  else
+    longjmp_resume_breakpoint->frame = 0;
+}
+
 /* Set a breakpoint that will evaporate an end of command
    at address specified by SAL.
    Restrict it to frame FRAME if FRAME is nonzero.  */
 
-void
-set_momentary_breakpoint (sal, frame)
+struct breakpoint *
+set_momentary_breakpoint (sal, frame, type)
      struct symtab_and_line sal;
      FRAME frame;
+     enum bptype type;
 {
   register struct breakpoint *b;
   b = set_raw_breakpoint (sal);
-  b->number = -3;
-  b->enable = delete;
+  b->type = type;
+  b->enable = enabled;
+  b->disposition = donttouch;
   b->frame = (frame ? FRAME_FP (frame) : 0);
+  return b;
 }
 
+#if 0
 void
 clear_momentary_breakpoints ()
 {
   register struct breakpoint *b;
   ALL_BREAKPOINTS (b)
-    if (b->number == -3)
+    if (b->disposition == delete)
       {
 	delete_breakpoint (b);
 	break;
       }
 }
+#endif
 
 /* Tell the user we have just set a breakpoint B.  */
 static void
 mention (b)
      struct breakpoint *b;
 {
-  if (b->exp)
+  switch (b->type)
     {
+    case bp_watchpoint:
       printf_filtered ("Watchpoint %d: ", b->number);
       print_expression (b->exp, stdout);
-    }
-  else
-    {
+      break;
+    case bp_breakpoint:
       printf_filtered ("Breakpoint %d at %s", b->number,
 		       local_hex_string(b->address));
       if (b->symtab)
@@ -1222,25 +1415,22 @@ set_breakpoint (s, line, tempflag, addr_string)
   
   sal.symtab = s;
   sal.line = line;
-  sal.pc = find_line_pc (sal.symtab, sal.line);
-  if (sal.pc == 0)
-    error ("No line %d in file \"%s\".\n", sal.line, sal.symtab->filename);
-  else
-    {
-      describe_other_breakpoints (sal.pc);
+  sal.pc = 0;
+  resolve_sal_pc (&sal);			/* Might error out */
+  describe_other_breakpoints (sal.pc);
 
-      b = set_raw_breakpoint (sal);
-      set_breakpoint_count (breakpoint_count + 1);
-      b->number = breakpoint_count;
-      b->cond = 0;
-      b->addr_string = addr_string;
-      if (tempflag)
-	b->enable = temporary;
+  b = set_raw_breakpoint (sal);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->type = bp_breakpoint;
+  b->cond = 0;
+  b->addr_string = addr_string;
+  b->enable = enabled;
+  b->disposition = tempflag ? delete : donttouch;
 
-      mention (b);
-    }
+  mention (b);
 }
-#endif
+#endif /* 0 */
 
 /* Set a breakpoint according to ARG (function, linenum or *address)
    and make it temporary if TEMPFLAG is nonzero. */
@@ -1264,7 +1454,6 @@ break_command_1 (arg, tempflag, from_tty)
   char *addr_end;
   
   int i;
-  CORE_ADDR pc;
 
   sals.sals = NULL;
   sals.nelts = 0;
@@ -1312,18 +1501,11 @@ break_command_1 (arg, tempflag, from_tty)
   if (! sals.nelts) 
     return;
 
+  /* Resolve all line numbers to PC's, and verify that conditions
+     can be parsed, before setting any breakpoints.  */
   for (i = 0; i < sals.nelts; i++)
     {
-      sal = sals.sals[i];
-      if (sal.pc == 0 && sal.symtab != 0)
-	{
-	  pc = find_line_pc (sal.symtab, sal.line);
-	  if (pc == 0)
-	    error ("No line %d in file \"%s\".",
-		   sal.line, sal.symtab->filename);
-	}
-      else 
-	pc = sal.pc;
+      resolve_sal_pc (&sals.sals[i]);
       
       while (arg && *arg)
 	{
@@ -1332,15 +1514,15 @@ break_command_1 (arg, tempflag, from_tty)
 	    {
 	      arg += 2;
 	      cond_start = arg;
-	      cond = parse_exp_1 (&arg, block_for_pc (pc), 0);
+	      cond = parse_exp_1 (&arg, block_for_pc (sals.sals[i].pc), 0);
 	      cond_end = arg;
 	    }
 	  else
 	    error ("Junk at end of arguments.");
 	}
-      sals.sals[i].pc = pc;
     }
 
+  /* Now set all the breakpoints.  */
   for (i = 0; i < sals.nelts; i++)
     {
       sal = sals.sals[i];
@@ -1351,6 +1533,7 @@ break_command_1 (arg, tempflag, from_tty)
       b = set_raw_breakpoint (sal);
       set_breakpoint_count (breakpoint_count + 1);
       b->number = breakpoint_count;
+      b->type = bp_breakpoint;
       b->cond = cond;
       
       if (addr_start)
@@ -1358,8 +1541,8 @@ break_command_1 (arg, tempflag, from_tty)
       if (cond_start)
 	b->cond_string = savestring (cond_start, cond_end - cond_start);
 				     
-      if (tempflag)
-	b->enable = temporary;
+      b->enable = enabled;
+      b->disposition = tempflag ? delete : donttouch;
 
       mention (b);
     }
@@ -1372,6 +1555,24 @@ break_command_1 (arg, tempflag, from_tty)
   free (sals.sals);
 }
 
+/* Helper function for break_command_1 and disassemble_command.  */
+
+void
+resolve_sal_pc (sal)
+     struct symtab_and_line *sal;
+{
+  CORE_ADDR pc;
+
+  if (sal->pc == 0 && sal->symtab != 0)
+    {
+      pc = find_line_pc (sal->symtab, sal->line);
+      if (pc == 0)
+	error ("No line %d in file \"%s\".",
+	       sal->line, sal->symtab->filename);
+      sal->pc = pc;
+    }
+}
+
 void
 break_command (arg, from_tty)
      char *arg;
@@ -1400,7 +1601,7 @@ watch_command (arg, from_tty)
   struct block *exp_valid_block;
   struct value *val;
 
-  sal.pc = NULL;
+  sal.pc = 0;
   sal.symtab = NULL;
   sal.line = 0;
   
@@ -1415,6 +1616,8 @@ watch_command (arg, from_tty)
   b = set_raw_breakpoint (sal);
   set_breakpoint_count (breakpoint_count + 1);
   b->number = breakpoint_count;
+  b->type = bp_watchpoint;
+  b->disposition = donttouch;
   b->exp = exp;
   b->exp_valid_block = exp_valid_block;
   b->val = val;
@@ -1436,6 +1639,8 @@ until_break_command (arg, from_tty)
   struct symtabs_and_lines sals;
   struct symtab_and_line sal;
   FRAME prev_frame = get_prev_frame (selected_frame);
+  struct breakpoint *breakpoint;
+  struct cleanup *old_chain;
 
   clear_proceed_status ();
 
@@ -1457,14 +1662,12 @@ until_break_command (arg, from_tty)
   if (*arg)
     error ("Junk at end of arguments.");
   
-  if (sal.pc == 0 && sal.symtab != 0)
-    sal.pc = find_line_pc (sal.symtab, sal.line);
+  resolve_sal_pc (&sal);
   
-  if (sal.pc == 0)
-    error ("No line %d in file \"%s\".", sal.line, sal.symtab->filename);
-  
-  set_momentary_breakpoint (sal, selected_frame);
+  breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
   
+  old_chain = make_cleanup(delete_breakpoint, breakpoint);
+
   /* Keep within the current frame */
   
   if (prev_frame)
@@ -1474,10 +1677,12 @@ until_break_command (arg, from_tty)
       fi = get_frame_info (prev_frame);
       sal = find_pc_line (fi->pc, 0);
       sal.pc = fi->pc;
-      set_momentary_breakpoint (sal, prev_frame);
+      breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
+      make_cleanup(delete_breakpoint, breakpoint);
     }
   
   proceed (-1, -1, 0);
+  do_cleanups(old_chain);
 }
 
 #if 0
@@ -1579,7 +1784,6 @@ static struct symtabs_and_lines
 get_catch_sals (this_level_only)
      int this_level_only;
 {
-  extern struct blockvector *blockvector_for_pc ();
   register struct blockvector *bl;
   register struct block *block;
   int index, have_default = 0;
@@ -1692,7 +1896,7 @@ get_catch_sals (this_level_only)
 
 /* Commands to deal with catching exceptions.  */
 
-void
+static void
 catch_command_1 (arg, tempflag, from_tty)
      char *arg;
      int tempflag;
@@ -1707,7 +1911,6 @@ catch_command_1 (arg, tempflag, from_tty)
   register struct breakpoint *b;
   char *save_arg;
   int i;
-  CORE_ADDR pc;
 
   sal.line = sal.pc = sal.end = 0;
   sal.symtab = 0;
@@ -1737,28 +1940,18 @@ catch_command_1 (arg, tempflag, from_tty)
   save_arg = arg;
   for (i = 0; i < sals.nelts; i++)
     {
-      sal = sals.sals[i];
-      if (sal.pc == 0 && sal.symtab != 0)
-	{
-	  pc = find_line_pc (sal.symtab, sal.line);
-	  if (pc == 0)
-	    error ("No line %d in file \"%s\".",
-		   sal.line, sal.symtab->filename);
-	}
-      else 
-	pc = sal.pc;
+      resolve_sal_pc (&sals.sals[i]);
       
       while (arg && *arg)
 	{
 	  if (arg[0] == 'i' && arg[1] == 'f'
 	      && (arg[2] == ' ' || arg[2] == '\t'))
-	    cond = (struct expression *) parse_exp_1 ((arg += 2, &arg),
-						    block_for_pc (pc), 0);
+	    cond = parse_exp_1 ((arg += 2, &arg), 
+				block_for_pc (sals.sals[i].pc), 0);
 	  else
 	    error ("Junk at end of arguments.");
 	}
       arg = save_arg;
-      sals.sals[i].pc = pc;
     }
 
   for (i = 0; i < sals.nelts; i++)
@@ -1769,10 +1962,12 @@ catch_command_1 (arg, tempflag, from_tty)
 	describe_other_breakpoints (sal.pc);
 
       b = set_raw_breakpoint (sal);
-      b->number = ++breakpoint_count;
+      set_breakpoint_count (breakpoint_count + 1);
+      b->number = breakpoint_count;
+      b->type = bp_breakpoint;
       b->cond = cond;
-      if (tempflag)
-	b->enable = temporary;
+      b->enable = enabled;
+      b->disposition = tempflag ? delete : donttouch;
 
       printf ("Breakpoint %d at %s", b->number, local_hex_string(b->address));
       if (b->symtab)
@@ -1870,7 +2065,7 @@ clear_command (arg, from_tty)
 
       ALL_BREAKPOINTS (b)
 	while (b->next
-	       && b->next->address != NULL
+	       && b->next->type != bp_watchpoint
 	       && (sal.pc ? b->next->address == sal.pc
 		   : (b->next->symtab == sal.symtab
 		      && b->next->line_number == sal.line)))
@@ -1911,13 +2106,13 @@ breakpoint_auto_delete (bs)
      bpstat bs;
 {
   for (; bs; bs = bs->next)
-    if (bs->breakpoint_at && bs->breakpoint_at->enable == delete)
+    if (bs->breakpoint_at && bs->breakpoint_at->disposition == delete)
       delete_breakpoint (bs->breakpoint_at);
 }
 
 /* Delete a breakpoint and clean up all traces of it in the data structures. */
 
-static void
+void
 delete_breakpoint (bpt)
      struct breakpoint *bpt;
 {
@@ -1947,7 +2142,7 @@ delete_breakpoint (bpt)
   if (bpt->addr_string != NULL)
     free (bpt->addr_string);
 
-  if (xgdb_verbose && bpt->number >=0)
+  if (xgdb_verbose && bpt->type == bp_breakpoint)
     printf ("breakpoint #%d deleted\n", bpt->number);
 
   /* Be sure no bpstat's are pointing at it after it's been freed.  */
@@ -1958,8 +2153,6 @@ delete_breakpoint (bpt)
   free (bpt);
 }
 
-static void map_breakpoint_numbers ();
-
 static void
 delete_command (arg, from_tty)
      char *arg;
@@ -1992,36 +2185,34 @@ breakpoint_re_set_one (bint)
   struct breakpoint *b = (struct breakpoint *)bint;  /* get past catch_errs */
   int i;
   struct symtabs_and_lines sals;
-  struct symtab_and_line sal;
   char *s;
+  enum enable save_enable;
 
-  if (b->address != NULL && b->addr_string != NULL)
+  if (b->type != bp_watchpoint && b->addr_string != NULL)
     {
+      /* In case we have a problem, disable this breakpoint.  We'll restore
+	 its status if we succeed.  */
+      save_enable = b->enable;
+      b->enable = disabled;
+
       s = b->addr_string;
       sals = decode_line_1 (&s, 1, (struct symtab *)NULL, 0);
       for (i = 0; i < sals.nelts; i++)
 	{
-	  sal = sals.sals[i];
-	  
-	  b->symtab = sal.symtab;
-	  b->line_number = sal.line;
-	  if (sal.pc == 0 && sal.symtab != 0)
-	    {
-	      sal.pc = find_line_pc (sal.symtab, sal.line);
-	      if (sal.pc == 0)
-		error ("No line %d in file \"%s\".",
-		       sal.line, sal.symtab->filename);
-	    }
-	  b->address = sal.pc;
+	  resolve_sal_pc (&sals.sals[i]);
+	  b->symtab = sals.sals[i].symtab;
+	  b->line_number = sals.sals[i].line;
+	  b->address = sals.sals[i].pc;
 
 	  if (b->cond_string != NULL)
 	    {
 	      s = b->cond_string;
-	      b->cond = parse_exp_1 (&s, block_for_pc (sal.pc), 0);
+	      b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
 	    }
 	  
 	  check_duplicates (b->address);
 
+	  b->enable = save_enable;	/* Restore it, this worked. */
 	  mention (b);
 	}
       free (sals.sals);
@@ -2039,12 +2230,14 @@ void
 breakpoint_re_set ()
 {
   struct breakpoint *b;
+  static char message1[] = "Error in re-setting breakpoint %d:\n";
+  char message[sizeof (message1) + 30 /* slop */];
   
   ALL_BREAKPOINTS (b)
     {
       b->symtab = 0;		/* Be sure we don't point to old dead symtab */
-      (void) catch_errors (breakpoint_re_set_one, (char *) b, 
-			   "Error in re-setting breakpoint:\n");
+      sprintf (message, message1, b->number);	/* Format possible error msg */
+      (void) catch_errors (breakpoint_re_set_one, (char *) b, message);
     }
 
   /* Blank line to finish off all those mention() messages we just printed.  */
@@ -2123,7 +2316,7 @@ ignore_command (args, from_tty)
 static void
 map_breakpoint_numbers (args, function)
      char *args;
-     void (*function) ();
+     void (*function) PARAMS ((struct breakpoint *));
 {
   register char *p = args;
   char *p1;
@@ -2157,11 +2350,11 @@ enable_breakpoint (bpt)
 {
   bpt->enable = enabled;
 
-  if (xgdb_verbose && bpt->number >= 0)
+  if (xgdb_verbose && bpt->type == bp_breakpoint)
     printf ("breakpoint #%d enabled\n", bpt->number);
 
   check_duplicates (bpt->address);
-  if (bpt->val != NULL)
+  if (bpt->type == bp_watchpoint)
     {
       if (bpt->exp_valid_block != NULL
        && !contained_in (get_selected_block (), bpt->exp_valid_block))
@@ -2199,7 +2392,7 @@ disable_breakpoint (bpt)
 {
   bpt->enable = disabled;
 
-  if (xgdb_verbose && bpt->number >= 0)
+  if (xgdb_verbose && bpt->type == bp_breakpoint)
     printf ("breakpoint #%d disabled\n", bpt->number);
 
   check_duplicates (bpt->address);
@@ -2223,7 +2416,8 @@ static void
 enable_once_breakpoint (bpt)
      struct breakpoint *bpt;
 {
-  bpt->enable = temporary;
+  bpt->enable = enabled;
+  bpt->disposition = disable;
 
   check_duplicates (bpt->address);
 }
@@ -2241,7 +2435,8 @@ static void
 enable_delete_breakpoint (bpt)
      struct breakpoint *bpt;
 {
-  bpt->enable = delete;
+  bpt->enable = enabled;
+  bpt->disposition = delete;
 
   check_duplicates (bpt->address);
 }