This commit was manufactured by cvs2svn to create branch

'carlton_dictionary-branch'.

Cherrypick from master 2002-09-20 14:58:59 UTC Fernando Nasser <fnasser@redhat.com> '        * source.c: Make global variables current_source_symtab and':
    gdb/breakpoint.c
    gdb/mi/ChangeLog
    gdb/printcmd.c
    gdb/stack.c
    gdb/tracepoint.c
    gdb/valops.c
Cherrypick from gdb_5_3-branch 2002-09-03 22:29:15 UTC nobody 'This commit was manufactured by cvs2svn to create branch 'gdb_5_3-branch'.':
    gdb/mi/mi-cmd-stack.c
    gdb/objfiles.c

8 files changed, 21922 insertions, 0 deletions

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
new file mode 100644
index 0000000..caa8f1c
--- /dev/null
+++ b/gdb/breakpoint.c
@@ -0,0 +1,7823 @@
+/* Everything about breakpoints, for GDB.
+
+   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
+   Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include <ctype.h>
+#include "symtab.h"
+#include "frame.h"
+#include "breakpoint.h"
+#include "gdbtypes.h"
+#include "expression.h"
+#include "gdbcore.h"
+#include "gdbcmd.h"
+#include "value.h"
+#include "command.h"
+#include "inferior.h"
+#include "gdbthread.h"
+#include "target.h"
+#include "language.h"
+#include "gdb_string.h"
+#include "demangle.h"
+#include "annotate.h"
+#include "symfile.h"
+#include "objfiles.h"
+#include "source.h"
+#include "linespec.h"
+#include "completer.h"
+#include "gdb.h"
+#include "ui-out.h"
+#include "cli/cli-script.h"
+
+#include "gdb-events.h"
+
+/* Prototypes for local functions. */
+
+static void until_break_command_continuation (struct continuation_arg *arg);
+
+static void catch_command_1 (char *, int, int);
+
+static void enable_delete_command (char *, int);
+
+static void enable_delete_breakpoint (struct breakpoint *);
+
+static void enable_once_command (char *, int);
+
+static void enable_once_breakpoint (struct breakpoint *);
+
+static void disable_command (char *, int);
+
+static void enable_command (char *, int);
+
+static void map_breakpoint_numbers (char *, void (*)(struct breakpoint *));
+
+static void ignore_command (char *, int);
+
+static int breakpoint_re_set_one (PTR);
+
+static void clear_command (char *, int);
+
+static void catch_command (char *, int);
+
+static void handle_gnu_4_16_catch_command (char *, int, int);
+
+static struct symtabs_and_lines get_catch_sals (int);
+
+static void watch_command (char *, int);
+
+static int can_use_hardware_watchpoint (struct value *);
+
+extern void break_at_finish_command (char *, int);
+extern void break_at_finish_at_depth_command (char *, int);
+
+extern void tbreak_at_finish_command (char *, int);
+
+static void break_command_1 (char *, int, int);
+
+static void mention (struct breakpoint *);
+
+struct breakpoint *set_raw_breakpoint (struct symtab_and_line, enum bptype);
+
+static void check_duplicates (struct breakpoint *);
+
+static void describe_other_breakpoints (CORE_ADDR, asection *);
+
+static void breakpoints_info (char *, int);
+
+static void breakpoint_1 (int, int);
+
+static bpstat bpstat_alloc (struct breakpoint *, bpstat);
+
+static int breakpoint_cond_eval (PTR);
+
+static void cleanup_executing_breakpoints (PTR);
+
+static void commands_command (char *, int);
+
+static void condition_command (char *, int);
+
+static int get_number_trailer (char **, int);
+
+void set_breakpoint_count (int);
+
+typedef enum
+  {
+    mark_inserted,
+    mark_uninserted
+  }
+insertion_state_t;
+
+static int remove_breakpoint (struct breakpoint *, insertion_state_t);
+
+static enum print_stop_action print_it_typical (bpstat);
+
+static enum print_stop_action print_bp_stop_message (bpstat bs);
+
+typedef struct
+  {
+    enum exception_event_kind kind;
+    int enable_p;
+  }
+args_for_catchpoint_enable;
+
+static int watchpoint_check (PTR);
+
+static int cover_target_enable_exception_callback (PTR);
+
+static void maintenance_info_breakpoints (char *, int);
+
+static void create_longjmp_breakpoint (char *);
+
+static void create_overlay_event_breakpoint (char *);
+
+static int hw_breakpoint_used_count (void);
+
+static int hw_watchpoint_used_count (enum bptype, int *);
+
+static void hbreak_command (char *, int);
+
+static void thbreak_command (char *, int);
+
+static void watch_command_1 (char *, int, int);
+
+static void rwatch_command (char *, int);
+
+static void awatch_command (char *, int);
+
+static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
+
+static void solib_load_unload_1 (char *hookname,
+				 int tempflag,
+				 char *dll_pathname,
+				 char *cond_string, enum bptype bp_kind);
+
+static void create_fork_vfork_event_catchpoint (int tempflag,
+						char *cond_string,
+						enum bptype bp_kind);
+
+static void break_at_finish_at_depth_command_1 (char *arg,
+						int flag, int from_tty);
+
+static void break_at_finish_command_1 (char *arg, int flag, int from_tty);
+
+static void stop_command (char *arg, int from_tty);
+
+static void stopin_command (char *arg, int from_tty);
+
+static void stopat_command (char *arg, int from_tty);
+
+static char *ep_find_event_name_end (char *arg);
+
+static char *ep_parse_optional_if_clause (char **arg);
+
+static char *ep_parse_optional_filename (char **arg);
+
+#if defined(CHILD_INSERT_EXEC_CATCHPOINT)
+static void catch_exec_command_1 (char *arg, int tempflag, int from_tty);
+#endif
+
+static void create_exception_catchpoint (int tempflag, char *cond_string,
+					 enum exception_event_kind ex_event,
+					 struct symtab_and_line *sal);
+
+static void catch_exception_command_1 (enum exception_event_kind ex_event, 
+				       char *arg, int tempflag, int from_tty);
+
+static void tcatch_command (char *arg, int from_tty);
+
+static void ep_skip_leading_whitespace (char **s);
+
+/* Prototypes for exported functions. */
+
+/* If FALSE, gdb will not use hardware support for watchpoints, even
+   if such is available. */
+static int can_use_hw_watchpoints;
+
+void _initialize_breakpoint (void);
+
+extern int addressprint;	/* Print machine addresses? */
+
+/* Are we executing breakpoint commands?  */
+static int executing_breakpoint_commands;
+
+/* Are overlay event breakpoints enabled? */
+static int overlay_events_enabled;
+
+/* Walk the following statement or block through all breakpoints.
+   ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current
+   breakpoint.  */
+
+#define ALL_BREAKPOINTS(B)  for (B = breakpoint_chain; B; B = B->next)
+
+#define ALL_BREAKPOINTS_SAFE(B,TMP)	\
+	for (B = breakpoint_chain;	\
+	     B ? (TMP=B->next, 1): 0;	\
+	     B = TMP)
+
+/* True if SHIFT_INST_REGS defined, false otherwise.  */
+
+int must_shift_inst_regs =
+#if defined(SHIFT_INST_REGS)
+1
+#else
+0
+#endif
+ ;
+
+/* True if breakpoint hit counts should be displayed in breakpoint info.  */
+
+int show_breakpoint_hit_counts = 1;
+
+/* Chain of all breakpoints defined.  */
+
+struct breakpoint *breakpoint_chain;
+
+/* Number of last breakpoint made.  */
+
+int breakpoint_count;
+
+/* Pointer to current exception event record */
+static struct exception_event_record *current_exception_event;
+
+/* Indicator of whether exception catchpoints should be nuked
+   between runs of a program */
+int exception_catchpoints_are_fragile = 0;
+
+/* Indicator of when exception catchpoints set-up should be
+   reinitialized -- e.g. when program is re-run */
+int exception_support_initialized = 0;
+
+/* This function returns a pointer to the string representation of the
+   pathname of the dynamically-linked library that has just been
+   loaded.
+
+   This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE,
+   or undefined results are guaranteed.
+
+   This string's contents are only valid immediately after the
+   inferior has stopped in the dynamic linker hook, and becomes
+   invalid as soon as the inferior is continued.  Clients should make
+   a copy of this string if they wish to continue the inferior and
+   then access the string.  */
+
+#ifndef SOLIB_LOADED_LIBRARY_PATHNAME
+#define SOLIB_LOADED_LIBRARY_PATHNAME(pid) ""
+#endif
+
+/* This function returns a pointer to the string representation of the
+   pathname of the dynamically-linked library that has just been
+   unloaded.
+
+   This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is
+   TRUE, or undefined results are guaranteed.
+
+   This string's contents are only valid immediately after the
+   inferior has stopped in the dynamic linker hook, and becomes
+   invalid as soon as the inferior is continued.  Clients should make
+   a copy of this string if they wish to continue the inferior and
+   then access the string.  */
+
+#ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME
+#define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) ""
+#endif
+
+/* This function is called by the "catch load" command.  It allows the
+   debugger to be notified by the dynamic linker when a specified
+   library file (or any library file, if filename is NULL) is loaded.  */
+
+#ifndef SOLIB_CREATE_CATCH_LOAD_HOOK
+#define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \
+   error ("catch of library loads not yet implemented on this platform")
+#endif
+
+/* This function is called by the "catch unload" command.  It allows
+   the debugger to be notified by the dynamic linker when a specified
+   library file (or any library file, if filename is NULL) is
+   unloaded.  */
+
+#ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK
+#define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \
+   error ("catch of library unloads not yet implemented on this platform")
+#endif
+
+/* Set breakpoint count to NUM.  */
+
+void
+set_breakpoint_count (int num)
+{
+  breakpoint_count = num;
+  set_internalvar (lookup_internalvar ("bpnum"),
+		   value_from_longest (builtin_type_int, (LONGEST) num));
+}
+
+/* Used in run_command to zero the hit count when a new run starts. */
+
+void
+clear_breakpoint_hit_counts (void)
+{
+  struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    b->hit_count = 0;
+}
+
+/* Default address, symtab and line to put a breakpoint at
+   for "break" command with no arg.
+   if default_breakpoint_valid is zero, the other three are
+   not valid, and "break" with no arg is an error.
+
+   This set by print_stack_frame, which calls set_default_breakpoint.  */
+
+int default_breakpoint_valid;
+CORE_ADDR default_breakpoint_address;
+struct symtab *default_breakpoint_symtab;
+int default_breakpoint_line;
+
+/* *PP is a string denoting a breakpoint.  Get the number of the breakpoint.
+   Advance *PP after the string and any trailing whitespace.
+
+   Currently the string can either be a number or "$" followed by the name
+   of a convenience variable.  Making it an expression wouldn't work well
+   for map_breakpoint_numbers (e.g. "4 + 5 + 6").
+   
+   TRAILER is a character which can be found after the number; most
+   commonly this is `-'.  If you don't want a trailer, use \0.  */ 
+static int
+get_number_trailer (char **pp, int trailer)
+{
+  int retval = 0;	/* default */
+  char *p = *pp;
+
+  if (p == NULL)
+    /* Empty line means refer to the last breakpoint.  */
+    return breakpoint_count;
+  else if (*p == '$')
+    {
+      /* Make a copy of the name, so we can null-terminate it
+         to pass to lookup_internalvar().  */
+      char *varname;
+      char *start = ++p;
+      struct value *val;
+
+      while (isalnum (*p) || *p == '_')
+	p++;
+      varname = (char *) alloca (p - start + 1);
+      strncpy (varname, start, p - start);
+      varname[p - start] = '\0';
+      val = value_of_internalvar (lookup_internalvar (varname));
+      if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
+	retval = (int) value_as_long (val);
+      else
+	{
+	  printf_filtered ("Convenience variable must have integer value.\n");
+	  retval = 0;
+	}
+    }
+  else
+    {
+      if (*p == '-')
+	++p;
+      while (*p >= '0' && *p <= '9')
+	++p;
+      if (p == *pp)
+	/* There is no number here.  (e.g. "cond a == b").  */
+	{
+	  /* Skip non-numeric token */
+	  while (*p && !isspace((int) *p))
+	    ++p;
+	  /* Return zero, which caller must interpret as error. */
+	  retval = 0;
+	}
+      else
+	retval = atoi (*pp);
+    }
+  if (!(isspace (*p) || *p == '\0' || *p == trailer))
+    {
+      /* Trailing junk: return 0 and let caller print error msg. */
+      while (!(isspace (*p) || *p == '\0' || *p == trailer))
+	++p;
+      retval = 0;
+    }
+  while (isspace (*p))
+    p++;
+  *pp = p;
+  return retval;
+}
+
+
+/* Like get_number_trailer, but don't allow a trailer.  */
+int
+get_number (char **pp)
+{
+  return get_number_trailer (pp, '\0');
+}
+
+/* Parse a number or a range.
+ * A number will be of the form handled by get_number.
+ * A range will be of the form <number1> - <number2>, and 
+ * will represent all the integers between number1 and number2,
+ * inclusive.
+ *
+ * While processing a range, this fuction is called iteratively;
+ * At each call it will return the next value in the range.
+ *
+ * At the beginning of parsing a range, the char pointer PP will
+ * be advanced past <number1> and left pointing at the '-' token.
+ * Subsequent calls will not advance the pointer until the range
+ * is completed.  The call that completes the range will advance
+ * pointer PP past <number2>.
+ */
+
+int 
+get_number_or_range (char **pp)
+{
+  static int last_retval, end_value;
+  static char *end_ptr;
+  static int in_range = 0;
+
+  if (**pp != '-')
+    {
+      /* Default case: pp is pointing either to a solo number, 
+	 or to the first number of a range.  */
+      last_retval = get_number_trailer (pp, '-');
+      if (**pp == '-')
+	{
+	  char **temp;
+
+	  /* This is the start of a range (<number1> - <number2>).
+	     Skip the '-', parse and remember the second number,
+	     and also remember the end of the final token.  */
+
+	  temp = &end_ptr; 
+	  end_ptr = *pp + 1; 
+	  while (isspace ((int) *end_ptr))
+	    end_ptr++;	/* skip white space */
+	  end_value = get_number (temp);
+	  if (end_value < last_retval) 
+	    {
+	      error ("inverted range");
+	    }
+	  else if (end_value == last_retval)
+	    {
+	      /* degenerate range (number1 == number2).  Advance the
+		 token pointer so that the range will be treated as a
+		 single number.  */ 
+	      *pp = end_ptr;
+	    }
+	  else
+	    in_range = 1;
+	}
+    }
+  else if (! in_range)
+    error ("negative value");
+  else
+    {
+      /* pp points to the '-' that betokens a range.  All
+	 number-parsing has already been done.  Return the next
+	 integer value (one greater than the saved previous value).
+	 Do not advance the token pointer 'pp' until the end of range
+	 is reached.  */
+
+      if (++last_retval == end_value)
+	{
+	  /* End of range reached; advance token pointer.  */
+	  *pp = end_ptr;
+	  in_range = 0;
+	}
+    }
+  return last_retval;
+}
+
+
+
+/* condition N EXP -- set break condition of breakpoint N to EXP.  */
+
+static void
+condition_command (char *arg, int from_tty)
+{
+  register struct breakpoint *b;
+  char *p;
+  register int bnum;
+
+  if (arg == 0)
+    error_no_arg ("breakpoint number");
+
+  p = arg;
+  bnum = get_number (&p);
+  if (bnum == 0)
+    error ("Bad breakpoint argument: '%s'", arg);
+
+  ALL_BREAKPOINTS (b)
+    if (b->number == bnum)
+    {
+      if (b->cond)
+	{
+	  xfree (b->cond);
+	  b->cond = 0;
+	}
+      if (b->cond_string != NULL)
+	xfree (b->cond_string);
+
+      if (*p == 0)
+	{
+	  b->cond = 0;
+	  b->cond_string = NULL;
+	  if (from_tty)
+	    printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
+	}
+      else
+	{
+	  arg = p;
+	  /* I don't know if it matters whether this is the string the user
+	     typed in or the decompiled expression.  */
+	  b->cond_string = savestring (arg, strlen (arg));
+	  b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
+	  if (*arg)
+	    error ("Junk at end of expression");
+	}
+      breakpoints_changed ();
+      breakpoint_modify_event (b->number);
+      return;
+    }
+
+  error ("No breakpoint number %d.", bnum);
+}
+
+/* ARGSUSED */
+static void
+commands_command (char *arg, int from_tty)
+{
+  register struct breakpoint *b;
+  char *p;
+  register int bnum;
+  struct command_line *l;
+
+  /* If we allowed this, we would have problems with when to
+     free the storage, if we change the commands currently
+     being read from.  */
+
+  if (executing_breakpoint_commands)
+    error ("Can't use the \"commands\" command among a breakpoint's commands.");
+
+  p = arg;
+  bnum = get_number (&p);
+
+  if (p && *p)
+    error ("Unexpected extra arguments following breakpoint number.");
+
+  ALL_BREAKPOINTS (b)
+    if (b->number == bnum)
+    {
+      char tmpbuf[128];
+      sprintf (tmpbuf, 
+	       "Type commands for when breakpoint %d is hit, one per line.", 
+	       bnum);
+      l = read_command_lines (tmpbuf, from_tty);
+      free_command_lines (&b->commands);
+      b->commands = l;
+      breakpoints_changed ();
+      breakpoint_modify_event (b->number);
+      return;
+    }
+  error ("No breakpoint number %d.", bnum);
+}
+
+/* Like target_read_memory() but if breakpoints are inserted, return
+   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 (CORE_ADDR memaddr, char *myaddr, unsigned len)
+{
+  int status;
+  struct breakpoint *b;
+  CORE_ADDR bp_addr = 0;
+  int bp_size = 0;
+
+  if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
+    /* No breakpoints on this machine. */
+    return target_read_memory (memaddr, myaddr, len);
+
+  ALL_BREAKPOINTS (b)
+  {
+    if (b->type == bp_none)
+      warning ("reading through apparently deleted breakpoint #%d?", 
+	       b->number);
+
+    /* memory breakpoint? */
+    if (b->type == bp_watchpoint
+	|| b->type == bp_hardware_watchpoint
+	|| b->type == bp_read_watchpoint
+	|| b->type == bp_access_watchpoint)
+      continue;
+    /* bp in memory? */
+    if (!b->inserted)
+      continue;
+    /* Addresses and length of the part of the breakpoint that
+       we need to copy.  */
+    /* XXXX The m68k, sh and h8300 have different local and remote
+       breakpoint values.  BREAKPOINT_FROM_PC still manages to
+       correctly determine the breakpoints memory address and size
+       for these targets. */
+    bp_addr = b->address;
+    bp_size = 0;
+    if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL)
+      continue;
+    if (bp_size == 0)
+      /* bp isn't valid */
+      continue;
+    if (bp_addr + bp_size <= memaddr)
+      /* The breakpoint is entirely before the chunk of memory we
+         are reading.  */
+      continue;
+    if (bp_addr >= memaddr + len)
+      /* The breakpoint is entirely after the chunk of memory we are
+         reading. */
+      continue;
+    /* Copy the breakpoint from the shadow contents, and recurse for
+       the things before and after.  */
+    {
+      /* Offset within shadow_contents.  */
+      int bptoffset = 0;
+
+      if (bp_addr < memaddr)
+	{
+	  /* Only copy the second part of the breakpoint.  */
+	  bp_size -= memaddr - bp_addr;
+	  bptoffset = memaddr - bp_addr;
+	  bp_addr = memaddr;
+	}
+
+      if (bp_addr + bp_size > memaddr + len)
+	{
+	  /* Only copy the first part of the breakpoint.  */
+	  bp_size -= (bp_addr + bp_size) - (memaddr + len);
+	}
+
+      memcpy (myaddr + bp_addr - memaddr,
+	      b->shadow_contents + bptoffset, bp_size);
+
+      if (bp_addr > memaddr)
+	{
+	  /* Copy the section of memory before the breakpoint.  */
+	  status = read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr);
+	  if (status != 0)
+	    return status;
+	}
+
+      if (bp_addr + bp_size < memaddr + len)
+	{
+	  /* Copy the section of memory after the breakpoint.  */
+	  status = read_memory_nobpt (bp_addr + bp_size,
+				      myaddr + bp_addr + bp_size - memaddr,
+				      memaddr + len - (bp_addr + bp_size));
+	  if (status != 0)
+	    return status;
+	}
+      return 0;
+    }
+  }
+  /* Nothing overlaps.  Just call read_memory_noerr.  */
+  return target_read_memory (memaddr, myaddr, len);
+}
+
+
+/* insert_breakpoints is used when starting or continuing the program.
+   remove_breakpoints is used when the program stops.
+   Both return zero if successful,
+   or an `errno' value if could not write the inferior.  */
+
+int
+insert_breakpoints (void)
+{
+  register struct breakpoint *b, *temp;
+  int return_val = 0;	/* return success code. */
+  int val = 0;
+  int disabled_breaks = 0;
+  int hw_breakpoint_error = 0;
+#ifdef ONE_PROCESS_WRITETEXT
+  int process_warning = 0;
+#endif
+
+  static char message1[] = "Error inserting catchpoint %d:\n";
+  static char message[sizeof (message1) + 30];
+
+  struct ui_file *tmp_error_stream = mem_fileopen ();
+  make_cleanup_ui_file_delete (tmp_error_stream);
+
+  /* Explicitly mark the warning -- this will only be printed if
+     there was an error.  */
+  fprintf_unfiltered (tmp_error_stream, "Warning:\n");
+
+  ALL_BREAKPOINTS_SAFE (b, temp)
+  {
+    if (b->enable_state == bp_permanent)
+      /* Permanent breakpoints cannot be inserted or removed.  */
+      continue;
+    if ((b->type == bp_watchpoint
+	 || b->type == bp_hardware_watchpoint
+	 || b->type == bp_read_watchpoint
+	 || b->type == bp_access_watchpoint) && (!b->val))
+      {
+	struct value *val;
+	val = evaluate_expression (b->exp);
+	release_value (val);
+	if (VALUE_LAZY (val))
+	  value_fetch_lazy (val);
+	b->val = val;
+      } 
+    if (b->type != bp_watchpoint
+	&& b->type != bp_hardware_watchpoint
+	&& b->type != bp_read_watchpoint
+	&& b->type != bp_access_watchpoint
+	&& b->type != bp_catch_fork
+	&& b->type != bp_catch_vfork
+	&& b->type != bp_catch_exec
+	&& b->type != bp_catch_throw
+	&& b->type != bp_catch_catch
+	&& b->enable_state != bp_disabled
+	&& b->enable_state != bp_shlib_disabled
+	&& b->enable_state != bp_call_disabled
+	&& !b->inserted
+	&& !b->duplicate)
+      {
+	/* "Normal" instruction breakpoint: either the standard
+	   trap-instruction bp (bp_breakpoint), or a
+	   bp_hardware_breakpoint.  */
+
+	/* First check to see if we have to handle an overlay.  */
+	if (overlay_debugging == ovly_off
+	    || b->section == NULL
+	    || !(section_is_overlay (b->section)))
+	  {
+	    /* No overlay handling: just set the breakpoint.  */
+
+	    if (b->type == bp_hardware_breakpoint)
+	      val = target_insert_hw_breakpoint (b->address, 
+						 b->shadow_contents);
+	    else
+	      val = target_insert_breakpoint (b->address, b->shadow_contents);
+	  }
+	else
+	  {
+	    /* This breakpoint is in an overlay section.  
+	       Shall we set a breakpoint at the LMA?  */
+	    if (!overlay_events_enabled)
+	      {
+		/* Yes -- overlay event support is not active, 
+		   so we must try to set a breakpoint at the LMA.
+		   This will not work for a hardware breakpoint.  */
+		if (b->type == bp_hardware_breakpoint)
+		  warning ("hardware breakpoint %d not supported in overlay!\n",
+			   b->number);
+		else
+		  {
+		    CORE_ADDR addr = overlay_unmapped_address (b->address, 
+							       b->section);
+		    /* Set a software (trap) breakpoint at the LMA.  */
+		    val = target_insert_breakpoint (addr, b->shadow_contents);
+		    if (val != 0)
+		      fprintf_unfiltered (tmp_error_stream, 
+					  "Overlay breakpoint %d failed: in ROM?", 
+					  b->number);
+		  }
+	      }
+	    /* Shall we set a breakpoint at the VMA? */
+	    if (section_is_mapped (b->section))
+	      {
+		/* Yes.  This overlay section is mapped into memory.  */
+		if (b->type == bp_hardware_breakpoint)
+		  val = target_insert_hw_breakpoint (b->address, 
+						     b->shadow_contents);
+		else
+		  val = target_insert_breakpoint (b->address,
+						  b->shadow_contents);
+	      }
+	    else
+	      {
+		/* No.  This breakpoint will not be inserted.  
+		   No error, but do not mark the bp as 'inserted'.  */
+		continue;
+	      }
+	  }
+
+	if (val)
+	  {
+	    /* Can't set the breakpoint.  */
+#if defined (DISABLE_UNSETTABLE_BREAK)
+	    if (DISABLE_UNSETTABLE_BREAK (b->address))
+	      {
+		/* See also: disable_breakpoints_in_shlibs. */
+		val = 0;
+		b->enable_state = bp_shlib_disabled;
+		if (!disabled_breaks)
+		  {
+		    fprintf_unfiltered (tmp_error_stream, 
+					"Cannot insert breakpoint %d.\n", 
+					b->number);
+		    fprintf_unfiltered (tmp_error_stream, 
+					"Temporarily disabling shared library breakpoints:\n");
+		  }
+		disabled_breaks = 1;
+		fprintf_unfiltered (tmp_error_stream, 
+				    "breakpoint #%d\n", b->number);
+	      }
+	    else
+#endif
+	      {
+#ifdef ONE_PROCESS_WRITETEXT
+		process_warning = 1;
+#endif
+		if (b->type == bp_hardware_breakpoint)
+		  {
+		    hw_breakpoint_error = 1;
+		    fprintf_unfiltered (tmp_error_stream, 
+					"Cannot insert hardware breakpoint %d.\n",
+					b->number);
+		  }
+		else
+		  {
+		    fprintf_unfiltered (tmp_error_stream, 
+					"Cannot insert breakpoint %d.\n", 
+					b->number);
+		    fprintf_filtered (tmp_error_stream, 
+				      "Error accessing memory address ");
+		    print_address_numeric (b->address, 1, tmp_error_stream);
+		    fprintf_filtered (tmp_error_stream, ": %s.\n",
+				      safe_strerror (val));
+		  }
+
+	      }
+	  }
+	else
+	  b->inserted = 1;
+
+	if (val)
+	  return_val = val;	/* remember failure */
+      }
+    else if (ep_is_exception_catchpoint (b)
+	     && b->enable_state != bp_disabled
+	     && b->enable_state != bp_shlib_disabled
+	     && b->enable_state != bp_call_disabled
+	     && !b->inserted
+	     && !b->duplicate)
+
+      {
+	/* If we get here, we must have a callback mechanism for exception
+	   events -- with g++ style embedded label support, we insert
+	   ordinary breakpoints and not catchpoints. */
+	/* Format possible error message */
+	sprintf (message, message1, b->number);
+
+	val = target_insert_breakpoint (b->address, b->shadow_contents);
+	if (val)
+	  {
+	    /* Couldn't set breakpoint for some reason */
+	    fprintf_unfiltered (tmp_error_stream, 
+				"Cannot insert catchpoint %d; disabling it.\n",
+				b->number);
+	    fprintf_filtered (tmp_error_stream, 
+			      "Error accessing memory address ");
+	    print_address_numeric (b->address, 1, tmp_error_stream);
+	    fprintf_filtered (tmp_error_stream, ": %s.\n",
+			      safe_strerror (val));
+	    b->enable_state = bp_disabled;
+	  }
+	else
+	  {
+	    /* Bp set, now make sure callbacks are enabled */
+	    int val;
+	    args_for_catchpoint_enable args;
+	    args.kind = b->type == bp_catch_catch ? 
+	      EX_EVENT_CATCH : EX_EVENT_THROW;
+	    args.enable_p = 1;
+	    val = catch_errors (cover_target_enable_exception_callback,
+				&args,
+				message, RETURN_MASK_ALL);
+	    if (val != 0 && val != -1)
+	      {
+		b->inserted = 1;
+	      }
+	    /* Check if something went wrong; val == 0 can be ignored */
+	    if (val == -1)
+	      {
+		/* something went wrong */
+		fprintf_unfiltered (tmp_error_stream, 
+				    "Cannot insert catchpoint %d; disabling it.\n",
+				    b->number);
+		b->enable_state = bp_disabled;
+	      }
+	  }
+
+	if (val)
+	  return_val = val;	/* remember failure */
+      }
+
+    else if ((b->type == bp_hardware_watchpoint ||
+	      b->type == bp_read_watchpoint ||
+	      b->type == bp_access_watchpoint)
+	     && b->enable_state == bp_enabled
+	     && b->disposition != disp_del_at_next_stop
+	     && !b->inserted
+	     && !b->duplicate)
+      {
+	struct frame_info *saved_frame;
+	int saved_level, within_current_scope;
+	struct value *mark = value_mark ();
+	struct value *v;
+
+	/* Save the current frame and level so we can restore it after
+	   evaluating the watchpoint expression on its own frame.  */
+	saved_frame = selected_frame;
+	saved_level = frame_relative_level (selected_frame);
+
+	/* Determine if the watchpoint is within scope.  */
+	if (b->exp_valid_block == NULL)
+	  within_current_scope = 1;
+	else
+	  {
+	    struct frame_info *fi;
+	    fi = frame_find_by_id (b->watchpoint_frame);
+	    within_current_scope = (fi != NULL);
+	    if (within_current_scope)
+	      select_frame (fi);
+	  }
+
+	if (within_current_scope)
+	  {
+	    /* Evaluate the expression and cut the chain of values
+	       produced off from the value chain.
+
+	       Make sure the value returned isn't lazy; we use
+	       laziness to determine what memory GDB actually needed
+	       in order to compute the value of the expression.  */
+	    v = evaluate_expression (b->exp);
+	    VALUE_CONTENTS(v);
+	    value_release_to_mark (mark);
+
+	    b->val_chain = v;
+	    b->inserted = 1;
+
+	    /* Look at each value on the value chain.  */
+	    for (; v; v = v->next)
+	      {
+		/* If it's a memory location, and GDB actually needed
+                   its contents to evaluate the expression, then we
+                   must watch it.  */
+		if (VALUE_LVAL (v) == lval_memory
+		    && ! VALUE_LAZY (v))
+		  {
+		    struct type *vtype = check_typedef (VALUE_TYPE (v));
+
+		    /* We only watch structs and arrays if user asked
+		       for it explicitly, never if they just happen to
+		       appear in the middle of some value chain.  */
+		    if (v == b->val_chain
+			|| (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
+			    && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
+		      {
+			CORE_ADDR addr;
+			int len, type;
+
+			addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
+			len = TYPE_LENGTH (VALUE_TYPE (v));
+			type = hw_write;
+			if (b->type == bp_read_watchpoint)
+			  type = hw_read;
+			else if (b->type == bp_access_watchpoint)
+			  type = hw_access;
+
+			val = target_insert_watchpoint (addr, len, type);
+			if (val == -1)
+			  {
+			    /* Don't exit the loop, try to insert
+			       every value on the value chain.  That's
+			       because we will be removing all the
+			       watches below, and removing a
+			       watchpoint we didn't insert could have
+			       adverse effects.  */
+			    b->inserted = 0;
+			  }
+			val = 0;
+		      }
+		  }
+	      }
+	    /* Failure to insert a watchpoint on any memory value in the
+	       value chain brings us here.  */
+	    if (!b->inserted)
+	      {
+		remove_breakpoint (b, mark_uninserted);
+		hw_breakpoint_error = 1;
+		fprintf_unfiltered (tmp_error_stream,
+				    "Could not insert hardware watchpoint %d.\n", 
+				    b->number);
+		val = -1;
+	      }               
+	  }
+	else
+	  {
+	    printf_filtered ("Hardware watchpoint %d deleted ", b->number);
+	    printf_filtered ("because the program has left the block \n");
+	    printf_filtered ("in which its expression is valid.\n");
+	    if (b->related_breakpoint)
+	      b->related_breakpoint->disposition = disp_del_at_next_stop;
+	    b->disposition = disp_del_at_next_stop;
+	  }
+
+	/* Restore the frame and level.  */
+	if ((saved_frame != selected_frame) ||
+	    (saved_level != frame_relative_level (selected_frame)))
+	  select_frame (saved_frame);
+
+	if (val)
+	  return_val = val;	/* remember failure */
+      }
+    else if ((b->type == bp_catch_fork
+	      || b->type == bp_catch_vfork
+	      || b->type == bp_catch_exec)
+	     && b->enable_state == bp_enabled
+	     && !b->inserted
+	     && !b->duplicate)
+      {
+	val = -1;
+	switch (b->type)
+	  {
+	  case bp_catch_fork:
+	    val = target_insert_fork_catchpoint (PIDGET (inferior_ptid));
+	    break;
+	  case bp_catch_vfork:
+	    val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
+	    break;
+	  case bp_catch_exec:
+	    val = target_insert_exec_catchpoint (PIDGET (inferior_ptid));
+	    break;
+	  default:
+	    warning ("Internal error, %s line %d.", __FILE__, __LINE__);
+	    break;
+	  }
+	if (val < 0)
+	  {
+	    fprintf_unfiltered (tmp_error_stream, 
+				"Cannot insert catchpoint %d.", b->number);
+	  }
+	else
+	  b->inserted = 1;
+
+	if (val)
+	  return_val = val;	/* remember failure */
+      }
+  }
+  
+  if (return_val) 
+    {
+      /* If a hardware breakpoint or watchpoint was inserted, add a
+         message about possibly exhausted resources.  */
+      if (hw_breakpoint_error)  
+	{
+	  fprintf_unfiltered (tmp_error_stream, 
+			      "Could not insert hardware breakpoints:\n\
+You may have requested too many hardware breakpoints/watchpoints.\n");
+	}
+#ifdef ONE_PROCESS_WRITETEXT
+      if (process_warning)
+	fprintf_unfiltered (tmp_error_stream,
+			    "The same program may be running in another process.");
+#endif
+      target_terminal_ours_for_output ();
+      error_stream (tmp_error_stream);
+    }
+  return return_val;
+}
+
+int
+remove_breakpoints (void)
+{
+  register struct breakpoint *b;
+  int val;
+
+  ALL_BREAKPOINTS (b)
+  {
+    if (b->inserted)
+      {
+	val = remove_breakpoint (b, mark_uninserted);
+	if (val != 0)
+	  return val;
+      }
+  }
+  return 0;
+}
+
+int
+remove_hw_watchpoints (void)
+{
+  register struct breakpoint *b;
+  int val;
+
+  ALL_BREAKPOINTS (b)
+  {
+    if (b->inserted
+	&& (b->type == bp_hardware_watchpoint
+	    || b->type == bp_read_watchpoint
+	    || b->type == bp_access_watchpoint))
+      {
+	val = remove_breakpoint (b, mark_uninserted);
+	if (val != 0)
+	  return val;
+      }
+  }
+  return 0;
+}
+
+int
+reattach_breakpoints (int pid)
+{
+  register struct breakpoint *b;
+  int val;
+  struct cleanup *old_chain = save_inferior_ptid ();
+
+  /* Set inferior_ptid; remove_breakpoint uses this global.  */
+  inferior_ptid = pid_to_ptid (pid);
+  ALL_BREAKPOINTS (b)
+  {
+    if (b->inserted)
+      {
+	remove_breakpoint (b, mark_inserted);
+	if (b->type == bp_hardware_breakpoint)
+	  val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
+	else
+	  val = target_insert_breakpoint (b->address, b->shadow_contents);
+	if (val != 0)
+	  {
+	    do_cleanups (old_chain);
+	    return val;
+	  }
+      }
+  }
+  do_cleanups (old_chain);
+  return 0;
+}
+
+void
+update_breakpoints_after_exec (void)
+{
+  struct breakpoint *b;
+  struct breakpoint *temp;
+
+  /* Doing this first prevents the badness of having delete_breakpoint()
+     write a breakpoint's current "shadow contents" to lift the bp.  That
+     shadow is NOT valid after an exec()! */
+  mark_breakpoints_out ();
+
+  ALL_BREAKPOINTS_SAFE (b, temp)
+  {
+    /* Solib breakpoints must be explicitly reset after an exec(). */
+    if (b->type == bp_shlib_event)
+      {
+	delete_breakpoint (b);
+	continue;
+      }
+
+    /* Thread event breakpoints must be set anew after an exec(),
+       as must overlay event breakpoints.  */
+    if (b->type == bp_thread_event || b->type == bp_overlay_event)
+      {
+	delete_breakpoint (b);
+	continue;
+      }
+
+    /* Step-resume breakpoints are meaningless after an exec(). */
+    if (b->type == bp_step_resume)
+      {
+	delete_breakpoint (b);
+	continue;
+      }
+
+    /* Ditto the sigtramp handler breakpoints. */
+    if (b->type == bp_through_sigtramp)
+      {
+	delete_breakpoint (b);
+	continue;
+      }
+
+    /* Ditto the exception-handling catchpoints. */
+    if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw))
+      {
+	delete_breakpoint (b);
+	continue;
+      }
+
+    /* Don't delete an exec catchpoint, because else the inferior
+       won't stop when it ought!
+
+       Similarly, we probably ought to keep vfork catchpoints, 'cause
+       on this target, we may not be able to stop when the vfork is
+       seen, but only when the subsequent exec is seen.  (And because
+       deleting fork catchpoints here but not vfork catchpoints will
+       seem mysterious to users, keep those too.)
+
+       ??rehrauer: Let's hope that merely clearing out this catchpoint's
+       target address field, if any, is sufficient to have it be reset
+       automagically.  Certainly on HP-UX that's true.
+
+       Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
+       valid code address on some platforms (like the mn10200 and
+       mn10300 simulators).  We shouldn't assign any special
+       interpretation to a breakpoint with a zero address.  And in
+       fact, GDB doesn't --- I can't see what that comment above is
+       talking about.  As far as I can tell, setting the address of a
+       bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
+       is meaningless, since those are implemented with HP-UX kernel
+       hackery, not by storing breakpoint instructions somewhere.  */
+    if ((b->type == bp_catch_exec) ||
+	(b->type == bp_catch_vfork) ||
+	(b->type == bp_catch_fork))
+      {
+	b->address = (CORE_ADDR) NULL;
+	continue;
+      }
+
+    /* bp_finish is a special case.  The only way we ought to be able
+       to see one of these when an exec() has happened, is if the user
+       caught a vfork, and then said "finish".  Ordinarily a finish just
+       carries them to the call-site of the current callee, by setting
+       a temporary bp there and resuming.  But in this case, the finish
+       will carry them entirely through the vfork & exec.
+
+       We don't want to allow a bp_finish to remain inserted now.  But
+       we can't safely delete it, 'cause finish_command has a handle to
+       the bp on a bpstat, and will later want to delete it.  There's a
+       chance (and I've seen it happen) that if we delete the bp_finish
+       here, that its storage will get reused by the time finish_command
+       gets 'round to deleting the "use to be a bp_finish" breakpoint.
+       We really must allow finish_command to delete a bp_finish.
+
+       In the absense of a general solution for the "how do we know
+       it's safe to delete something others may have handles to?"
+       problem, what we'll do here is just uninsert the bp_finish, and
+       let finish_command delete it.
+
+       (We know the bp_finish is "doomed" in the sense that it's
+       momentary, and will be deleted as soon as finish_command sees
+       the inferior stopped.  So it doesn't matter that the bp's
+       address is probably bogus in the new a.out, unlike e.g., the
+       solib breakpoints.)  */
+
+    if (b->type == bp_finish)
+      {
+	continue;
+      }
+
+    /* Without a symbolic address, we have little hope of the
+       pre-exec() address meaning the same thing in the post-exec()
+       a.out. */
+    if (b->addr_string == NULL)
+      {
+	delete_breakpoint (b);
+	continue;
+      }
+
+    /* If this breakpoint has survived the above battery of checks, then
+       it must have a symbolic address.  Be sure that it gets reevaluated
+       to a target address, rather than reusing the old evaluation.
+
+       Jim Blandy <jimb@redhat.com>: As explained above in the comment
+       for bp_catch_exec and friends, I'm pretty sure this is entirely
+       unnecessary.  A call to breakpoint_re_set_one always recomputes
+       the breakpoint's address from scratch, or deletes it if it can't.
+       So I think this assignment could be deleted without effect.  */
+    b->address = (CORE_ADDR) NULL;
+  }
+  /* FIXME what about longjmp breakpoints?  Re-create them here?  */
+  create_overlay_event_breakpoint ("_ovly_debug_event");
+}
+
+int
+detach_breakpoints (int pid)
+{
+  register struct breakpoint *b;
+  int val;
+  struct cleanup *old_chain = save_inferior_ptid ();
+
+  if (pid == PIDGET (inferior_ptid))
+    error ("Cannot detach breakpoints of inferior_ptid");
+
+  /* Set inferior_ptid; remove_breakpoint uses this global.  */
+  inferior_ptid = pid_to_ptid (pid);
+  ALL_BREAKPOINTS (b)
+  {
+    if (b->inserted)
+      {
+	val = remove_breakpoint (b, mark_inserted);
+	if (val != 0)
+	  {
+	    do_cleanups (old_chain);
+	    return val;
+	  }
+      }
+  }
+  do_cleanups (old_chain);
+  return 0;
+}
+
+static int
+remove_breakpoint (struct breakpoint *b, insertion_state_t is)
+{
+  int val;
+
+  if (b->enable_state == bp_permanent)
+    /* Permanent breakpoints cannot be inserted or removed.  */
+    return 0;
+
+  if (b->type == bp_none)
+    warning ("attempted to remove apparently deleted breakpoint #%d?", 
+	     b->number);
+
+  if (b->type != bp_watchpoint
+      && b->type != bp_hardware_watchpoint
+      && b->type != bp_read_watchpoint
+      && b->type != bp_access_watchpoint
+      && b->type != bp_catch_fork
+      && b->type != bp_catch_vfork
+      && b->type != bp_catch_exec
+      && b->type != bp_catch_catch
+      && b->type != bp_catch_throw)
+    {
+      /* "Normal" instruction breakpoint: either the standard
+	 trap-instruction bp (bp_breakpoint), or a
+	 bp_hardware_breakpoint.  */
+
+      /* First check to see if we have to handle an overlay.  */
+      if (overlay_debugging == ovly_off
+	  || b->section == NULL
+	  || !(section_is_overlay (b->section)))
+	{
+	  /* No overlay handling: just remove the breakpoint.  */
+
+	  if (b->type == bp_hardware_breakpoint)
+	    val = target_remove_hw_breakpoint (b->address, 
+					       b->shadow_contents);
+	  else
+	    val = target_remove_breakpoint (b->address, b->shadow_contents);
+	}
+      else
+	{
+	  /* This breakpoint is in an overlay section.  
+	     Did we set a breakpoint at the LMA?  */
+	  if (!overlay_events_enabled)
+	      {
+		/* Yes -- overlay event support is not active, so we
+		   should have set a breakpoint at the LMA.  Remove it.  
+		*/
+		CORE_ADDR addr = overlay_unmapped_address (b->address, 
+							   b->section);
+		/* Ignore any failures: if the LMA is in ROM, we will
+		   have already warned when we failed to insert it.  */
+		if (b->type != bp_hardware_breakpoint)
+		  target_remove_hw_breakpoint (addr, b->shadow_contents);
+		else
+		  target_remove_breakpoint (addr, b->shadow_contents);
+	      }
+	  /* Did we set a breakpoint at the VMA? 
+	     If so, we will have marked the breakpoint 'inserted'.  */
+	  if (b->inserted)
+	    {
+	      /* Yes -- remove it.  Previously we did not bother to
+		 remove the breakpoint if the section had been
+		 unmapped, but let's not rely on that being safe.  We
+		 don't know what the overlay manager might do.  */
+	      if (b->type == bp_hardware_breakpoint)
+		val = target_remove_hw_breakpoint (b->address, 
+						   b->shadow_contents);
+	      else
+		val = target_remove_breakpoint (b->address,
+						b->shadow_contents);
+	    }
+	  else
+	    {
+	      /* No -- not inserted, so no need to remove.  No error.  */
+	      val = 0;
+	    }
+	}
+      if (val)
+	return val;
+      b->inserted = (is == mark_inserted);
+    }
+  else if ((b->type == bp_hardware_watchpoint ||
+	    b->type == bp_read_watchpoint ||
+	    b->type == bp_access_watchpoint)
+	   && b->enable_state == bp_enabled
+	   && !b->duplicate)
+    {
+      struct value *v;
+      struct value *n;
+
+      b->inserted = (is == mark_inserted);
+      /* Walk down the saved value chain.  */
+      for (v = b->val_chain; v; v = v->next)
+	{
+	  /* For each memory reference remove the watchpoint
+	     at that address.  */
+	  if (VALUE_LVAL (v) == lval_memory
+	      && ! VALUE_LAZY (v))
+	    {
+	      struct type *vtype = check_typedef (VALUE_TYPE (v));
+
+	      if (v == b->val_chain
+		  || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
+		      && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
+		{
+		  CORE_ADDR addr;
+		  int len, type;
+
+		  addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
+		  len = TYPE_LENGTH (VALUE_TYPE (v));
+		  type   = hw_write;
+		  if (b->type == bp_read_watchpoint)
+		    type = hw_read;
+		  else if (b->type == bp_access_watchpoint)
+		    type = hw_access;
+
+		  val = target_remove_watchpoint (addr, len, type);
+		  if (val == -1)
+		    b->inserted = 1;
+		  val = 0;
+		}
+	    }
+	}
+      /* Failure to remove any of the hardware watchpoints comes here.  */
+      if ((is == mark_uninserted) && (b->inserted))
+	warning ("Could not remove hardware watchpoint %d.",
+		 b->number);
+
+      /* Free the saved value chain.  We will construct a new one
+         the next time the watchpoint is inserted.  */
+      for (v = b->val_chain; v; v = n)
+	{
+	  n = v->next;
+	  value_free (v);
+	}
+      b->val_chain = NULL;
+    }
+  else if ((b->type == bp_catch_fork ||
+	    b->type == bp_catch_vfork ||
+	    b->type == bp_catch_exec)
+	   && b->enable_state == bp_enabled
+	   && !b->duplicate)
+    {
+      val = -1;
+      switch (b->type)
+	{
+	case bp_catch_fork:
+	  val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
+	  break;
+	case bp_catch_vfork:
+	  val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
+	  break;
+	case bp_catch_exec:
+	  val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
+	  break;
+	default:
+	  warning ("Internal error, %s line %d.", __FILE__, __LINE__);
+	  break;
+	}
+      if (val)
+	return val;
+      b->inserted = (is == mark_inserted);
+    }
+  else if ((b->type == bp_catch_catch ||
+	    b->type == bp_catch_throw)
+	   && b->enable_state == bp_enabled
+	   && !b->duplicate)
+    {
+
+      val = target_remove_breakpoint (b->address, b->shadow_contents);
+      if (val)
+	return val;
+      b->inserted = (is == mark_inserted);
+    }
+  else if (ep_is_exception_catchpoint (b)
+	   && b->inserted	/* sometimes previous insert doesn't happen */
+	   && b->enable_state == bp_enabled
+	   && !b->duplicate)
+    {
+
+      val = target_remove_breakpoint (b->address, b->shadow_contents);
+      if (val)
+	return val;
+
+      b->inserted = (is == mark_inserted);
+    }
+
+  return 0;
+}
+
+/* Clear the "inserted" flag in all breakpoints.  */
+
+void
+mark_breakpoints_out (void)
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    b->inserted = 0;
+}
+
+/* Clear the "inserted" flag in all breakpoints and delete any
+   breakpoints which should go away between runs of the program.
+
+   Plus other such housekeeping that has to be done for breakpoints
+   between runs.
+
+   Note: this function gets called at the end of a run (by
+   generic_mourn_inferior) and when a run begins (by
+   init_wait_for_inferior). */
+
+
+
+void
+breakpoint_init_inferior (enum inf_context context)
+{
+  register struct breakpoint *b, *temp;
+  static int warning_needed = 0;
+
+  ALL_BREAKPOINTS_SAFE (b, temp)
+  {
+    b->inserted = 0;
+
+    switch (b->type)
+      {
+      case bp_call_dummy:
+      case bp_watchpoint_scope:
+
+	/* If the call dummy breakpoint is at the entry point it will
+	   cause problems when the inferior is rerun, so we better
+	   get rid of it. 
+
+	   Also get rid of scope breakpoints.  */
+	delete_breakpoint (b);
+	break;
+
+      case bp_watchpoint:
+      case bp_hardware_watchpoint:
+      case bp_read_watchpoint:
+      case bp_access_watchpoint:
+
+	/* Likewise for watchpoints on local expressions.  */
+	if (b->exp_valid_block != NULL)
+	  delete_breakpoint (b);
+	if (context == inf_starting) 
+	  {
+	    /* Reset val field to force reread of starting value
+	       in insert_breakpoints.  */
+	    if (b->val)
+	      value_free (b->val);
+	    b->val = NULL;
+	  }
+	break;
+      default:
+	/* Likewise for exception catchpoints in dynamic-linked
+	   executables where required */
+	if (ep_is_exception_catchpoint (b) &&
+	    exception_catchpoints_are_fragile)
+	  {
+	    warning_needed = 1;
+	    delete_breakpoint (b);
+	  }
+	break;
+      }
+  }
+
+  if (exception_catchpoints_are_fragile)
+    exception_support_initialized = 0;
+
+  /* Don't issue the warning unless it's really needed... */
+  if (warning_needed && (context != inf_exited))
+    {
+      warning ("Exception catchpoints from last run were deleted.");
+      warning ("You must reinsert them explicitly.");
+      warning_needed = 0;
+    }
+}
+
+/* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
+   exists at PC.  It returns ordinary_breakpoint_here if it's an
+   ordinary breakpoint, or permanent_breakpoint_here if it's a
+   permanent breakpoint.
+   - When continuing from a location with an ordinary breakpoint, we
+     actually single step once before calling insert_breakpoints.
+   - When continuing from a localion with a permanent breakpoint, we
+     need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
+     the target, to advance the PC past the breakpoint.  */
+
+enum breakpoint_here
+breakpoint_here_p (CORE_ADDR pc)
+{
+  register struct breakpoint *b;
+  int any_breakpoint_here = 0;
+
+  ALL_BREAKPOINTS (b)
+    if ((b->enable_state == bp_enabled
+	 || b->enable_state == bp_permanent)
+	&& b->address == pc)	/* bp is enabled and matches pc */
+      {
+	if (overlay_debugging 
+	    && section_is_overlay (b->section) 
+	    && !section_is_mapped (b->section))
+	  continue;		/* unmapped overlay -- can't be a match */
+	else if (b->enable_state == bp_permanent)
+	  return permanent_breakpoint_here;
+	else
+	  any_breakpoint_here = 1;
+      }
+
+  return any_breakpoint_here ? ordinary_breakpoint_here : 0;
+}
+
+
+/* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(),
+   but it only returns true if there is actually a breakpoint inserted
+   at PC.  */
+
+int
+breakpoint_inserted_here_p (CORE_ADDR pc)
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->inserted
+	&& b->address == pc)	/* bp is inserted and matches pc */
+    {
+      if (overlay_debugging 
+	  && section_is_overlay (b->section) 
+	  && !section_is_mapped (b->section))
+	continue;		/* unmapped overlay -- can't be a match */
+      else
+	return 1;
+    }
+
+  return 0;
+}
+
+/* Return nonzero if FRAME is a dummy frame.  We can't use
+   PC_IN_CALL_DUMMY because figuring out the saved SP would take too
+   much time, at least using get_saved_register on the 68k.  This
+   means that for this function to work right a port must use the
+   bp_call_dummy breakpoint.  */
+
+int
+frame_in_dummy (struct frame_info *frame)
+{
+  struct breakpoint *b;
+
+  if (!CALL_DUMMY_P)
+    return 0;
+
+  if (USE_GENERIC_DUMMY_FRAMES)
+    return generic_pc_in_call_dummy (frame->pc, frame->frame, frame->frame);
+
+  ALL_BREAKPOINTS (b)
+  {
+    if (b->type == bp_call_dummy
+	&& b->frame == frame->frame
+    /* We need to check the PC as well as the frame on the sparc,
+       for signals.exp in the testsuite.  */
+	&& (frame->pc
+	    >= (b->address
+	      - SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * REGISTER_SIZE))
+	&& frame->pc <= b->address)
+      return 1;
+  }
+  return 0;
+}
+
+/* breakpoint_thread_match (PC, PID) returns true if the breakpoint at
+   PC is valid for process/thread PID.  */
+
+int
+breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid)
+{
+  struct breakpoint *b;
+  int thread;
+
+  thread = pid_to_thread_id (ptid);
+
+  ALL_BREAKPOINTS (b)
+    if (b->enable_state != bp_disabled
+	&& b->enable_state != bp_shlib_disabled
+	&& b->enable_state != bp_call_disabled
+	&& b->address == pc
+	&& (b->thread == -1 || b->thread == thread))
+    {
+      if (overlay_debugging 
+	  && section_is_overlay (b->section) 
+	  && !section_is_mapped (b->section))
+	continue;		/* unmapped overlay -- can't be a match */
+      else
+	return 1;
+    }
+
+  return 0;
+}
+
+
+/* bpstat stuff.  External routines' interfaces are documented
+   in breakpoint.h.  */
+
+int
+ep_is_catchpoint (struct breakpoint *ep)
+{
+  return
+    (ep->type == bp_catch_load)
+    || (ep->type == bp_catch_unload)
+    || (ep->type == bp_catch_fork)
+    || (ep->type == bp_catch_vfork)
+    || (ep->type == bp_catch_exec)
+    || (ep->type == bp_catch_catch)
+    || (ep->type == bp_catch_throw);
+
+  /* ??rehrauer: Add more kinds here, as are implemented... */
+}
+
+int
+ep_is_shlib_catchpoint (struct breakpoint *ep)
+{
+  return
+    (ep->type == bp_catch_load)
+    || (ep->type == bp_catch_unload);
+}
+
+int
+ep_is_exception_catchpoint (struct breakpoint *ep)
+{
+  return
+    (ep->type == bp_catch_catch)
+    || (ep->type == bp_catch_throw);
+}
+
+/* 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 (bpstat *bsp)
+{
+  bpstat p;
+  bpstat q;
+
+  if (bsp == 0)
+    return;
+  p = *bsp;
+  while (p != NULL)
+    {
+      q = p->next;
+      if (p->old_val != NULL)
+	value_free (p->old_val);
+      free_command_lines (&p->commands);
+      xfree (p);
+      p = q;
+    }
+  *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 (bpstat bs)
+{
+  bpstat p = NULL;
+  bpstat tmp;
+  bpstat retval = NULL;
+
+  if (bs == NULL)
+    return bs;
+
+  for (; bs != NULL; bs = bs->next)
+    {
+      tmp = (bpstat) xmalloc (sizeof (*tmp));
+      memcpy (tmp, bs, sizeof (*tmp));
+      if (p == NULL)
+	/* This is the first thing in the chain.  */
+	retval = tmp;
+      else
+	p->next = tmp;
+      p = tmp;
+    }
+  p->next = NULL;
+  return retval;
+}
+
+/* Find the bpstat associated with this breakpoint */
+
+bpstat
+bpstat_find_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;
+}
+
+/* Find a step_resume breakpoint associated with this bpstat.
+   (If there are multiple step_resume bp's on the list, this function
+   will arbitrarily pick one.)
+
+   It is an error to use this function if BPSTAT doesn't contain a
+   step_resume breakpoint.
+
+   See wait_for_inferior's use of this function.  */
+struct breakpoint *
+bpstat_find_step_resume_breakpoint (bpstat bsp)
+{
+  int current_thread;
+
+  if (bsp == NULL)
+    error ("Internal error (bpstat_find_step_resume_breakpoint)");
+
+  current_thread = pid_to_thread_id (inferior_ptid);
+
+  for (; bsp != NULL; bsp = bsp->next)
+    {
+      if ((bsp->breakpoint_at != NULL) &&
+	  (bsp->breakpoint_at->type == bp_step_resume) &&
+	  (bsp->breakpoint_at->thread == current_thread || 
+	   bsp->breakpoint_at->thread == -1))
+	return bsp->breakpoint_at;
+    }
+
+  error ("Internal error (no step_resume breakpoint found)");
+}
+
+
+/* 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 (bpstat *bsp)
+{
+  struct breakpoint *b;
+
+  if ((*bsp) == NULL)
+    return 0;			/* No more breakpoint values */
+  else
+    {
+      b = (*bsp)->breakpoint_at;
+      *bsp = (*bsp)->next;
+      if (b == NULL)
+	return -1;		/* breakpoint that's been deleted since */
+      else
+	return b->number;	/* We have its number */
+    }
+}
+
+/* Modify BS so that the actions will not be performed.  */
+
+void
+bpstat_clear_actions (bpstat bs)
+{
+  for (; bs != NULL; bs = bs->next)
+    {
+      free_command_lines (&bs->commands);
+      if (bs->old_val != NULL)
+	{
+	  value_free (bs->old_val);
+	  bs->old_val = NULL;
+	}
+    }
+}
+
+/* Stub for cleaning up our state if we error-out of a breakpoint command */
+/* ARGSUSED */
+static void
+cleanup_executing_breakpoints (PTR ignore)
+{
+  executing_breakpoint_commands = 0;
+}
+
+/* Execute all the commands associated with all the breakpoints at this
+   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 (bpstat *bsp)
+{
+  bpstat bs;
+  struct cleanup *old_chain;
+  struct command_line *cmd;
+
+  /* Avoid endless recursion if a `source' command is contained
+     in bs->commands.  */
+  if (executing_breakpoint_commands)
+    return;
+
+  executing_breakpoint_commands = 1;
+  old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
+
+top:
+  /* Note that (as of this writing), our callers all appear to
+     be passing us the address of global stop_bpstat.  And, if
+     our calls to execute_control_command cause the inferior to
+     proceed, that global (and hence, *bsp) will change.
+
+     We must be careful to not touch *bsp unless the inferior
+     has not proceeded. */
+
+  /* This pointer will iterate over the list of bpstat's. */
+  bs = *bsp;
+
+  breakpoint_proceeded = 0;
+  for (; bs != NULL; bs = bs->next)
+    {
+      cmd = bs->commands;
+      while (cmd != NULL)
+	{
+	  execute_control_command (cmd);
+
+	  if (breakpoint_proceeded)
+	    break;
+	  else
+	    cmd = cmd->next;
+	}
+      if (breakpoint_proceeded)
+	/* The inferior is proceeded by the command; bomb out now.
+	   The bpstat chain has been blown away by wait_for_inferior.
+	   But since execution has stopped again, there is a new bpstat
+	   to look at, so start over.  */
+	goto top;
+      else
+	free_command_lines (&bs->commands);
+    }
+  do_cleanups (old_chain);
+}
+
+/* This is the normal print function for a bpstat.  In the future,
+   much of this logic could (should?) be moved to bpstat_stop_status,
+   by having it set different print_it values.
+
+   Current scheme: When we stop, bpstat_print() is called.  It loops
+   through the bpstat list of things causing this stop, calling the
+   print_bp_stop_message function on each one. The behavior of the
+   print_bp_stop_message function depends on the print_it field of
+   bpstat. If such field so indicates, call this function here.
+
+   Return values from this routine (ultimately used by bpstat_print()
+   and normal_stop() to decide what to do): 
+   PRINT_NOTHING: Means we already printed all we needed to print,
+   don't print anything else.
+   PRINT_SRC_ONLY: Means we printed something, and we do *not* desire
+   that something to be followed by a location.
+   PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire
+   that something to be followed by a location.
+   PRINT_UNKNOWN: Means we printed nothing or we need to do some more
+   analysis.  */
+
+static enum print_stop_action
+print_it_typical (bpstat bs)
+{
+  struct cleanup *old_chain;
+  struct ui_stream *stb;
+  stb = ui_out_stream_new (uiout);
+  old_chain = make_cleanup_ui_out_stream_delete (stb);
+  /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
+     which has since been deleted.  */
+  if (bs->breakpoint_at == NULL)
+    return PRINT_UNKNOWN;
+
+  switch (bs->breakpoint_at->type)
+    {
+    case bp_breakpoint:
+    case bp_hardware_breakpoint:
+      annotate_breakpoint (bs->breakpoint_at->number);
+      ui_out_text (uiout, "\nBreakpoint ");
+      if (ui_out_is_mi_like_p (uiout))
+	ui_out_field_string (uiout, "reason", "breakpoint-hit");
+      ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number);
+      ui_out_text (uiout, ", ");
+      return PRINT_SRC_AND_LOC;
+      break;
+
+    case bp_shlib_event:
+      /* Did we stop because the user set the stop_on_solib_events
+	 variable?  (If so, we report this as a generic, "Stopped due
+	 to shlib event" message.) */
+      printf_filtered ("Stopped due to shared library event\n");
+      return PRINT_NOTHING;
+      break;
+
+    case bp_thread_event:
+      /* Not sure how we will get here. 
+	 GDB should not stop for these breakpoints.  */
+      printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n");
+      return PRINT_NOTHING;
+      break;
+
+    case bp_overlay_event:
+      /* By analogy with the thread event, GDB should not stop for these. */
+      printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n");
+      return PRINT_NOTHING;
+      break;
+
+    case bp_catch_load:
+      annotate_catchpoint (bs->breakpoint_at->number);
+      printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
+      printf_filtered ("loaded");
+      printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
+      return PRINT_SRC_AND_LOC;
+      break;
+
+    case bp_catch_unload:
+      annotate_catchpoint (bs->breakpoint_at->number);
+      printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
+      printf_filtered ("unloaded");
+      printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname);
+      return PRINT_SRC_AND_LOC;
+      break;
+
+    case bp_catch_fork:
+      annotate_catchpoint (bs->breakpoint_at->number);
+      printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
+      printf_filtered ("forked");
+      printf_filtered (" process %d), ", 
+		       bs->breakpoint_at->forked_inferior_pid);
+      return PRINT_SRC_AND_LOC;
+      break;
+
+    case bp_catch_vfork:
+      annotate_catchpoint (bs->breakpoint_at->number);
+      printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number);
+      printf_filtered ("vforked");
+      printf_filtered (" process %d), ", 
+		       bs->breakpoint_at->forked_inferior_pid);
+      return PRINT_SRC_AND_LOC;
+      break;
+
+    case bp_catch_exec:
+      annotate_catchpoint (bs->breakpoint_at->number);
+      printf_filtered ("\nCatchpoint %d (exec'd %s), ",
+		       bs->breakpoint_at->number,
+		       bs->breakpoint_at->exec_pathname);
+      return PRINT_SRC_AND_LOC;
+      break;
+
+    case bp_catch_catch:
+      if (current_exception_event && 
+	  (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH))
+	{
+	  annotate_catchpoint (bs->breakpoint_at->number);
+	  printf_filtered ("\nCatchpoint %d (exception caught), ", 
+			   bs->breakpoint_at->number);
+	  printf_filtered ("throw location ");
+	  if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
+	    printf_filtered ("%s:%d",
+			     CURRENT_EXCEPTION_THROW_FILE,
+			     CURRENT_EXCEPTION_THROW_LINE);
+	  else
+	    printf_filtered ("unknown");
+
+	  printf_filtered (", catch location ");
+	  if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
+	    printf_filtered ("%s:%d",
+			     CURRENT_EXCEPTION_CATCH_FILE,
+			     CURRENT_EXCEPTION_CATCH_LINE);
+	  else
+	    printf_filtered ("unknown");
+
+	  printf_filtered ("\n");
+	  /* don't bother to print location frame info */
+	  return PRINT_SRC_ONLY;
+	}
+      else
+	{
+	  /* really throw, some other bpstat will handle it */
+	  return PRINT_UNKNOWN;	
+	}
+      break;
+
+    case bp_catch_throw:
+      if (current_exception_event && 
+	  (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW))
+	{
+	  annotate_catchpoint (bs->breakpoint_at->number);
+	  printf_filtered ("\nCatchpoint %d (exception thrown), ",
+			   bs->breakpoint_at->number);
+	  printf_filtered ("throw location ");
+	  if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE)
+	    printf_filtered ("%s:%d",
+			     CURRENT_EXCEPTION_THROW_FILE,
+			     CURRENT_EXCEPTION_THROW_LINE);
+	  else
+	    printf_filtered ("unknown");
+
+	  printf_filtered (", catch location ");
+	  if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE)
+	    printf_filtered ("%s:%d",
+			     CURRENT_EXCEPTION_CATCH_FILE,
+			     CURRENT_EXCEPTION_CATCH_LINE);
+	  else
+	    printf_filtered ("unknown");
+
+	  printf_filtered ("\n");
+	  /* don't bother to print location frame info */
+	  return PRINT_SRC_ONLY; 
+	}
+      else
+	{
+	  /* really catch, some other bpstat will handle it */
+	  return PRINT_UNKNOWN;	
+	}
+      break;
+
+    case bp_watchpoint:
+    case bp_hardware_watchpoint:
+      if (bs->old_val != NULL)
+	{
+	  annotate_watchpoint (bs->breakpoint_at->number);
+	  if (ui_out_is_mi_like_p (uiout))
+	    ui_out_field_string (uiout, "reason", "watchpoint-trigger");
+	  mention (bs->breakpoint_at);
+	  ui_out_tuple_begin (uiout, "value");
+	  ui_out_text (uiout, "\nOld value = ");
+	  value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
+	  ui_out_field_stream (uiout, "old", stb);
+	  ui_out_text (uiout, "\nNew value = ");
+	  value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
+	  ui_out_field_stream (uiout, "new", stb);
+	  ui_out_tuple_end (uiout);
+	  ui_out_text (uiout, "\n");
+	  value_free (bs->old_val);
+	  bs->old_val = NULL;
+	}
+      /* More than one watchpoint may have been triggered.  */
+      return PRINT_UNKNOWN;
+      break;
+
+    case bp_read_watchpoint:
+      if (ui_out_is_mi_like_p (uiout))
+	ui_out_field_string (uiout, "reason", "read-watchpoint-trigger");
+      mention (bs->breakpoint_at);
+      ui_out_tuple_begin (uiout, "value");
+      ui_out_text (uiout, "\nValue = ");
+      value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
+      ui_out_field_stream (uiout, "value", stb);
+      ui_out_tuple_end (uiout);
+      ui_out_text (uiout, "\n");
+      return PRINT_UNKNOWN;
+      break;
+
+    case bp_access_watchpoint:
+      if (bs->old_val != NULL)     
+	{
+	  annotate_watchpoint (bs->breakpoint_at->number);
+	  if (ui_out_is_mi_like_p (uiout))
+	    ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
+	  mention (bs->breakpoint_at);
+	  ui_out_tuple_begin (uiout, "value");
+	  ui_out_text (uiout, "\nOld value = ");
+	  value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
+	  ui_out_field_stream (uiout, "old", stb);
+	  value_free (bs->old_val);
+	  bs->old_val = NULL;
+	  ui_out_text (uiout, "\nNew value = ");
+	}
+      else 
+	{
+	  mention (bs->breakpoint_at);
+	  if (ui_out_is_mi_like_p (uiout))
+	    ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
+	  ui_out_tuple_begin (uiout, "value");
+	  ui_out_text (uiout, "\nValue = ");
+	}
+      value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default);
+      ui_out_field_stream (uiout, "new", stb);
+      ui_out_tuple_end (uiout);
+      ui_out_text (uiout, "\n");
+      return PRINT_UNKNOWN;
+      break;
+
+    /* Fall through, we don't deal with these types of breakpoints
+       here. */
+
+    case bp_finish:
+      if (ui_out_is_mi_like_p (uiout))
+	ui_out_field_string (uiout, "reason", "function-finished");
+      return PRINT_UNKNOWN;
+      break;
+
+    case bp_until:
+      if (ui_out_is_mi_like_p (uiout))
+	ui_out_field_string (uiout, "reason", "location-reached");
+      return PRINT_UNKNOWN;
+      break;
+
+    case bp_none:
+    case bp_longjmp:
+    case bp_longjmp_resume:
+    case bp_step_resume:
+    case bp_through_sigtramp:
+    case bp_watchpoint_scope:
+    case bp_call_dummy:
+    default:
+      return PRINT_UNKNOWN;
+    }
+}
+
+/* Generic routine for printing messages indicating why we
+   stopped. The behavior of this function depends on the value
+   'print_it' in the bpstat structure.  Under some circumstances we
+   may decide not to print anything here and delegate the task to
+   normal_stop(). */
+
+static enum print_stop_action
+print_bp_stop_message (bpstat bs)
+{
+  switch (bs->print_it)
+    {
+    case print_it_noop:
+      /* Nothing should be printed for this bpstat entry. */
+      return PRINT_UNKNOWN;
+      break;
+
+    case print_it_done:
+      /* We still want to print the frame, but we already printed the
+         relevant messages. */
+      return PRINT_SRC_AND_LOC;
+      break;
+
+    case print_it_normal:
+      /* Normal case, we handle everything in print_it_typical. */
+      return print_it_typical (bs);
+      break;
+    default:
+      internal_error (__FILE__, __LINE__,
+		      "print_bp_stop_message: unrecognized enum value");
+      break;
+    }
+}
+
+/* Print a message indicating what happened.  This is called from
+   normal_stop().  The input to this routine is the head of the bpstat
+   list - a list of the eventpoints that caused this stop.  This
+   routine calls the generic print routine for printing a message
+   about reasons for stopping.  This will print (for example) the
+   "Breakpoint n," part of the output.  The return value of this
+   routine is one of:
+
+   PRINT_UNKNOWN: Means we printed nothing
+   PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
+   code to print the location. An example is 
+   "Breakpoint 1, " which should be followed by
+   the location.
+   PRINT_SRC_ONLY: Means we printed something, but there is no need
+   to also print the location part of the message.
+   An example is the catch/throw messages, which
+   don't require a location appended to the end.  
+   PRINT_NOTHING: We have done some printing and we don't need any 
+   further info to be printed.*/
+
+enum print_stop_action
+bpstat_print (bpstat bs)
+{
+  int val;
+
+  /* Maybe another breakpoint in the chain caused us to stop.
+     (Currently all watchpoints go on the bpstat whether hit or not.
+     That probably could (should) be changed, provided care is taken
+     with respect to bpstat_explains_signal).  */
+  for (; bs; bs = bs->next)
+    {
+      val = print_bp_stop_message (bs);
+      if (val == PRINT_SRC_ONLY 
+	  || val == PRINT_SRC_AND_LOC 
+	  || val == PRINT_NOTHING)
+	return val;
+    }
+
+  /* We reached the end of the chain, or we got a null BS to start
+     with and nothing was printed. */
+  return PRINT_UNKNOWN;
+}
+
+/* Evaluate the expression EXP and return 1 if value is zero.
+   This is used inside a catch_errors to evaluate the breakpoint condition. 
+   The argument is a "struct expression *" that has been cast to char * to 
+   make it pass through catch_errors.  */
+
+static int
+breakpoint_cond_eval (PTR exp)
+{
+  struct value *mark = value_mark ();
+  int i = !value_true (evaluate_expression ((struct expression *) exp));
+  value_free_to_mark (mark);
+  return i;
+}
+
+/* Allocate a new bpstat and chain it to the current one.  */
+
+static bpstat
+bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ )
+{
+  bpstat bs;
+
+  bs = (bpstat) xmalloc (sizeof (*bs));
+  cbs->next = bs;
+  bs->breakpoint_at = b;
+  /* If the condition is false, etc., don't do the commands.  */
+  bs->commands = NULL;
+  bs->old_val = NULL;
+  bs->print_it = print_it_normal;
+  return bs;
+}
+
+/* Possible return values for watchpoint_check (this can't be an enum
+   because of check_errors).  */
+/* The watchpoint has been deleted.  */
+#define WP_DELETED 1
+/* The value has changed.  */
+#define WP_VALUE_CHANGED 2
+/* The value has not changed.  */
+#define WP_VALUE_NOT_CHANGED 3
+
+#define BP_TEMPFLAG 1
+#define BP_HARDWAREFLAG 2
+
+/* Check watchpoint condition.  */
+
+static int
+watchpoint_check (PTR p)
+{
+  bpstat bs = (bpstat) p;
+  struct breakpoint *b;
+  struct frame_info *fr;
+  int within_current_scope;
+
+  b = bs->breakpoint_at;
+
+  if (b->exp_valid_block == NULL)
+    within_current_scope = 1;
+  else
+    {
+      /* There is no current frame at this moment.  If we're going to have
+         any chance of handling watchpoints on local variables, we'll need
+         the frame chain (so we can determine if we're in scope).  */
+      reinit_frame_cache ();
+      fr = frame_find_by_id (b->watchpoint_frame);
+      within_current_scope = (fr != NULL);
+      /* in_function_epilogue_p() returns a non-zero value if we're still
+	 in the function but the stack frame has already been invalidated.
+	 Since we can't rely on the values of local variables after the
+	 stack has been destroyed, we are treating the watchpoint in that
+	 state as `not changed' without further checking. */
+      if (within_current_scope && fr == get_current_frame ()
+          && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ()))
+	return WP_VALUE_NOT_CHANGED;
+      if (within_current_scope)
+	/* If we end up stopping, the current frame will get selected
+	   in normal_stop.  So this call to select_frame won't affect
+	   the user.  */
+	select_frame (fr);
+    }
+
+  if (within_current_scope)
+    {
+      /* We use value_{,free_to_}mark because it could be a
+         *long* time before we return to the command level and
+         call free_all_values.  We can't call free_all_values because
+         we might be in the middle of evaluating a function call.  */
+
+      struct value *mark = value_mark ();
+      struct value *new_val = evaluate_expression (bs->breakpoint_at->exp);
+      if (!value_equal (b->val, new_val))
+	{
+	  release_value (new_val);
+	  value_free_to_mark (mark);
+	  bs->old_val = b->val;
+	  b->val = new_val;
+	  /* We will stop here */
+	  return WP_VALUE_CHANGED;
+	}
+      else
+	{
+	  /* Nothing changed, don't do anything.  */
+	  value_free_to_mark (mark);
+	  /* We won't stop here */
+	  return WP_VALUE_NOT_CHANGED;
+	}
+    }
+  else
+    {
+      /* This seems like the only logical thing to do because
+         if we temporarily ignored the watchpoint, then when
+         we reenter the block in which it is valid it contains
+         garbage (in the case of a function, it may have two
+         garbage values, one before and one after the prologue).
+         So we can't even detect the first assignment to it and
+         watch after that (since the garbage may or may not equal
+         the first value assigned).  */
+      /* We print all the stop information in print_it_typical(), but
+	 in this case, by the time we call print_it_typical() this bp
+	 will be deleted already. So we have no choice but print the
+	 information here. */
+      if (ui_out_is_mi_like_p (uiout))
+	ui_out_field_string (uiout, "reason", "watchpoint-scope");
+      ui_out_text (uiout, "\nWatchpoint ");
+      ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number);
+      ui_out_text (uiout, " deleted because the program has left the block in\n\
+which its expression is valid.\n");     
+
+      if (b->related_breakpoint)
+	b->related_breakpoint->disposition = disp_del_at_next_stop;
+      b->disposition = disp_del_at_next_stop;
+
+      return WP_DELETED;
+    }
+}
+
+/* Get a bpstat associated with having just stopped at address *PC
+   and frame address CORE_ADDRESS.  Update *PC to point at the
+   breakpoint (if we hit a breakpoint).  NOT_A_SW_BREAKPOINT is nonzero
+   if this is known to not be a real breakpoint (it could still be a
+   watchpoint, though).  */
+
+/* Determine whether we stopped at a breakpoint, etc, or whether we
+   don't understand this stop.  Result is a chain of bpstat's such that:
+
+   if we don't understand the stop, the result is a null pointer.
+
+   if we understand why we stopped, the result is not null.
+
+   Each element of the chain refers to a particular breakpoint or
+   watchpoint at which we have stopped.  (We may have stopped for
+   several reasons concurrently.)
+
+   Each element of the chain has valid next, breakpoint_at,
+   commands, FIXME??? fields.  */
+
+bpstat
+bpstat_stop_status (CORE_ADDR *pc, int not_a_sw_breakpoint)
+{
+  register struct breakpoint *b, *temp;
+  CORE_ADDR bp_addr;
+  /* True if we've hit a breakpoint (as opposed to a watchpoint).  */
+  int real_breakpoint = 0;
+  /* Root of the chain of bpstat's */
+  struct bpstats root_bs[1];
+  /* Pointer to the last thing in the chain currently.  */
+  bpstat bs = root_bs;
+  static char message1[] =
+  "Error evaluating expression for watchpoint %d\n";
+  char message[sizeof (message1) + 30 /* slop */ ];
+
+  /* Get the address where the breakpoint would have been.  The
+     "not_a_sw_breakpoint" argument is meant to distinguish between a
+     breakpoint trap event and a trace/singlestep trap event.  For a
+     trace/singlestep trap event, we would not want to subtract
+     DECR_PC_AFTER_BREAK from the PC. */
+
+  bp_addr = *pc - (not_a_sw_breakpoint ? 0 : DECR_PC_AFTER_BREAK);
+
+  ALL_BREAKPOINTS_SAFE (b, temp)
+  {
+    if (b->enable_state == bp_disabled
+	|| b->enable_state == bp_shlib_disabled
+	|| b->enable_state == bp_call_disabled)
+      continue;
+
+    if (b->type != bp_watchpoint
+	&& b->type != bp_hardware_watchpoint
+	&& b->type != bp_read_watchpoint
+	&& b->type != bp_access_watchpoint
+	&& b->type != bp_hardware_breakpoint
+	&& b->type != bp_catch_fork
+	&& b->type != bp_catch_vfork
+	&& b->type != bp_catch_exec
+	&& b->type != bp_catch_catch
+	&& b->type != bp_catch_throw)	/* a non-watchpoint bp */
+      {
+	if (b->address != bp_addr) 	/* address doesn't match */
+	  continue;
+	if (overlay_debugging		/* unmapped overlay section */
+	    && section_is_overlay (b->section) 
+	    && !section_is_mapped (b->section))
+	  continue;
+      }
+
+    if (b->type == bp_hardware_breakpoint)
+      {
+	if (b->address != (*pc - DECR_PC_AFTER_HW_BREAK))
+	  continue;
+	if (overlay_debugging		/* unmapped overlay section */
+	    && section_is_overlay (b->section) 
+	    && !section_is_mapped (b->section))
+	  continue;
+      }
+
+    /* Is this a catchpoint of a load or unload?  If so, did we
+       get a load or unload of the specified library?  If not,
+       ignore it. */
+    if ((b->type == bp_catch_load)
+#if defined(SOLIB_HAVE_LOAD_EVENT)
+	&& (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid))
+	    || ((b->dll_pathname != NULL)
+		&& (strcmp (b->dll_pathname, 
+			    SOLIB_LOADED_LIBRARY_PATHNAME (
+			      PIDGET (inferior_ptid)))
+		    != 0)))
+#endif
+      )
+      continue;
+
+    if ((b->type == bp_catch_unload)
+#if defined(SOLIB_HAVE_UNLOAD_EVENT)
+	&& (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid))
+	    || ((b->dll_pathname != NULL)
+		&& (strcmp (b->dll_pathname, 
+			    SOLIB_UNLOADED_LIBRARY_PATHNAME (
+			      PIDGET (inferior_ptid)))
+		    != 0)))
+#endif
+      )
+      continue;
+
+    if ((b->type == bp_catch_fork)
+	&& !target_has_forked (PIDGET (inferior_ptid),
+	                       &b->forked_inferior_pid))
+      continue;
+
+    if ((b->type == bp_catch_vfork)
+	&& !target_has_vforked (PIDGET (inferior_ptid),
+	                        &b->forked_inferior_pid))
+      continue;
+
+    if ((b->type == bp_catch_exec)
+	&& !target_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
+      continue;
+
+    if (ep_is_exception_catchpoint (b) &&
+	!(current_exception_event = target_get_current_exception_event ()))
+      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 */
+
+    /* Watchpoints may change this, if not found to have triggered. */
+    bs->stop = 1;
+    bs->print = 1;
+
+    sprintf (message, message1, b->number);
+    if (b->type == bp_watchpoint ||
+	b->type == bp_hardware_watchpoint)
+      {
+	switch (catch_errors (watchpoint_check, bs, message, 
+			      RETURN_MASK_ALL))
+	  {
+	  case WP_DELETED:
+	    /* We've already printed what needs to be printed.  */
+	    /* Actually this is superfluous, because by the time we
+               call print_it_typical() the wp will be already deleted,
+               and the function will return immediately. */
+	    bs->print_it = print_it_done;
+	    /* Stop.  */
+	    break;
+	  case WP_VALUE_CHANGED:
+	    /* Stop.  */
+	    ++(b->hit_count);
+	    break;
+	  case WP_VALUE_NOT_CHANGED:
+	    /* Don't stop.  */
+	    bs->print_it = print_it_noop;
+	    bs->stop = 0;
+	    continue;
+	  default:
+	    /* Can't happen.  */
+	    /* FALLTHROUGH */
+	  case 0:
+	    /* Error from catch_errors.  */
+	    printf_filtered ("Watchpoint %d deleted.\n", b->number);
+	    if (b->related_breakpoint)
+	      b->related_breakpoint->disposition = disp_del_at_next_stop;
+	    b->disposition = disp_del_at_next_stop;
+	    /* We've already printed what needs to be printed.  */
+	    bs->print_it = print_it_done;
+
+	    /* Stop.  */
+	    break;
+	  }
+      }
+    else if (b->type == bp_read_watchpoint || 
+	     b->type == bp_access_watchpoint)
+      {
+	CORE_ADDR addr;
+	struct value *v;
+	int found = 0;
+
+	addr = target_stopped_data_address ();
+	if (addr == 0)
+	  continue;
+	for (v = b->val_chain; v; v = v->next)
+	  {
+	    if (VALUE_LVAL (v) == lval_memory
+		&& ! VALUE_LAZY (v))
+	      {
+		struct type *vtype = check_typedef (VALUE_TYPE (v));
+
+		if (v == b->val_chain
+		    || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
+			&& TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
+		  {
+		    CORE_ADDR vaddr;
+
+		    vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
+		    /* Exact match not required.  Within range is
+                       sufficient.  */
+		    if (addr >= vaddr &&
+			addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v)))
+		      found = 1;
+		  }
+	      }
+	  }
+	if (found)
+	  switch (catch_errors (watchpoint_check, bs, message,
+				RETURN_MASK_ALL))
+	    {
+	    case WP_DELETED:
+	      /* We've already printed what needs to be printed.  */
+	      bs->print_it = print_it_done;
+	      /* Stop.  */
+	      break;
+	    case WP_VALUE_CHANGED:
+	      if (b->type == bp_read_watchpoint)
+		{
+		  /* Don't stop: read watchpoints shouldn't fire if
+		     the value has changed.  This is for targets which
+		     cannot set read-only watchpoints.  */
+		  bs->print_it = print_it_noop;
+		  bs->stop = 0;
+		  continue;
+		}
+	      ++(b->hit_count);
+	      break;
+	    case WP_VALUE_NOT_CHANGED:
+	      /* Stop.  */
+	      ++(b->hit_count);
+	      break;
+	    default:
+	      /* Can't happen.  */
+	    case 0:
+	      /* Error from catch_errors.  */
+	      printf_filtered ("Watchpoint %d deleted.\n", b->number);
+	      if (b->related_breakpoint)
+		b->related_breakpoint->disposition = disp_del_at_next_stop;
+	      b->disposition = disp_del_at_next_stop;
+	      /* We've already printed what needs to be printed.  */
+	      bs->print_it = print_it_done;
+	      break;
+	    }
+	else	/* found == 0 */
+	  {
+	    /* This is a case where some watchpoint(s) triggered,
+	       but not at the address of this watchpoint (FOUND
+	       was left zero).  So don't print anything for this
+	       watchpoint.  */
+	    bs->print_it = print_it_noop;
+	    bs->stop = 0;
+            continue;
+	  }
+      }
+    else
+      {
+	/* By definition, an encountered breakpoint is a triggered
+	   breakpoint. */
+	++(b->hit_count);
+
+	real_breakpoint = 1;
+      }
+
+    if (b->frame &&
+       b->frame != (get_current_frame ())->frame)
+      bs->stop = 0;
+    else
+      {
+	int value_is_zero = 0;
+
+	if (b->cond)
+	  {
+	    /* Need to select the frame, with all that implies
+	       so that the conditions will have the right context.  */
+	    select_frame (get_current_frame ());
+	    value_is_zero
+	      = catch_errors (breakpoint_cond_eval, (b->cond),
+			      "Error in testing breakpoint condition:\n",
+			      RETURN_MASK_ALL);
+	    /* FIXME-someday, should give breakpoint # */
+	    free_all_values ();
+	  }
+	if (b->cond && value_is_zero)
+	  {
+	    bs->stop = 0;
+	    /* Don't consider this a hit.  */
+	    --(b->hit_count);
+	  }
+	else if (b->ignore_count > 0)
+	  {
+	    b->ignore_count--;
+	    annotate_ignore_count_change ();
+	    bs->stop = 0;
+	  }
+	else
+	  {
+	    /* We will stop here */
+	    if (b->disposition == disp_disable)
+	      b->enable_state = bp_disabled;
+	    bs->commands = copy_command_lines (b->commands);
+	    if (b->silent)
+	      bs->print = 0;
+	    if (bs->commands &&
+		(STREQ ("silent", bs->commands->line) ||
+		 (xdb_commands && STREQ ("Q", bs->commands->line))))
+	      {
+		bs->commands = bs->commands->next;
+		bs->print = 0;
+	      }
+	  }
+      }
+    /* Print nothing for this entry if we dont stop or if we dont print.  */
+    if (bs->stop == 0 || bs->print == 0)
+      bs->print_it = print_it_noop;
+  }
+
+  bs->next = NULL;		/* Terminate the chain */
+  bs = root_bs->next;		/* Re-grab the head of the chain */
+
+  if (real_breakpoint && bs)
+    {
+      if (bs->breakpoint_at->type == bp_hardware_breakpoint)
+	{
+	  if (DECR_PC_AFTER_HW_BREAK != 0)
+	    {
+	      *pc = *pc - DECR_PC_AFTER_HW_BREAK;
+	      write_pc (*pc);
+	    }
+	}
+      else
+	{
+	  if (DECR_PC_AFTER_BREAK != 0 || must_shift_inst_regs)
+	    {
+	      *pc = bp_addr;
+#if defined (SHIFT_INST_REGS)
+	      SHIFT_INST_REGS ();
+#else /* No SHIFT_INST_REGS.  */
+	      write_pc (bp_addr);
+#endif /* No SHIFT_INST_REGS.  */
+	    }
+	}
+    }
+
+  /* The value of a hardware watchpoint hasn't changed, but the
+     intermediate memory locations we are watching may have.  */
+  if (bs && !bs->stop &&
+      (bs->breakpoint_at->type == bp_hardware_watchpoint ||
+       bs->breakpoint_at->type == bp_read_watchpoint ||
+       bs->breakpoint_at->type == bp_access_watchpoint))
+    {
+      remove_breakpoints ();
+      insert_breakpoints ();
+    }
+  return bs;
+}
+
+/* Tell what to do about this bpstat.  */
+struct bpstat_what
+bpstat_what (bpstat bs)
+{
+  /* Classify each bpstat as one of the following.  */
+  enum class
+    {
+      /* This bpstat element has no effect on the main_action.  */
+      no_effect = 0,
+
+      /* There was a watchpoint, stop but don't print.  */
+      wp_silent,
+
+      /* There was a watchpoint, stop and print.  */
+      wp_noisy,
+
+      /* There was a breakpoint but we're not stopping.  */
+      bp_nostop,
+
+      /* There was a breakpoint, stop but don't print.  */
+      bp_silent,
+
+      /* There was a breakpoint, stop and print.  */
+      bp_noisy,
+
+      /* We hit the longjmp breakpoint.  */
+      long_jump,
+
+      /* We hit the longjmp_resume breakpoint.  */
+      long_resume,
+
+      /* We hit the step_resume breakpoint.  */
+      step_resume,
+
+      /* We hit the through_sigtramp breakpoint.  */
+      through_sig,
+
+      /* We hit the shared library event breakpoint.  */
+      shlib_event,
+
+      /* We caught a shared library event.  */
+      catch_shlib_event,
+
+      /* This is just used to count how many enums there are.  */
+      class_last
+    };
+
+  /* Here is the table which drives this routine.  So that we can
+     format it pretty, we define some abbreviations for the
+     enum bpstat_what codes.  */
+#define kc BPSTAT_WHAT_KEEP_CHECKING
+#define ss BPSTAT_WHAT_STOP_SILENT
+#define sn BPSTAT_WHAT_STOP_NOISY
+#define sgl BPSTAT_WHAT_SINGLE
+#define slr BPSTAT_WHAT_SET_LONGJMP_RESUME
+#define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
+#define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
+#define sr BPSTAT_WHAT_STEP_RESUME
+#define ts BPSTAT_WHAT_THROUGH_SIGTRAMP
+#define shl BPSTAT_WHAT_CHECK_SHLIBS
+#define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
+
+/* "Can't happen."  Might want to print an error message.
+   abort() is not out of the question, but chances are GDB is just
+   a bit confused, not unusable.  */
+#define err BPSTAT_WHAT_STOP_NOISY
+
+  /* Given an old action and a class, come up with a new action.  */
+  /* One interesting property of this table is that wp_silent is the same
+     as bp_silent and wp_noisy is the same as bp_noisy.  That is because
+     after stopping, the check for whether to step over a breakpoint
+     (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without
+     reference to how we stopped.  We retain separate wp_silent and
+     bp_silent codes in case we want to change that someday. 
+
+     Another possibly interesting property of this table is that
+     there's a partial ordering, priority-like, of the actions.  Once
+     you've decided that some action is appropriate, you'll never go
+     back and decide something of a lower priority is better.  The
+     ordering is:
+
+     kc   < clr sgl shl shlr slr sn sr ss ts
+     sgl  < clrs shl shlr slr sn sr ss ts
+     slr  < err shl shlr sn sr ss ts
+     clr  < clrs err shl shlr sn sr ss ts
+     clrs < err shl shlr sn sr ss ts
+     ss   < shl shlr sn sr ts
+     sn   < shl shlr sr ts
+     sr   < shl shlr ts
+     shl  < shlr
+     ts   < 
+     shlr <
+
+     What I think this means is that we don't need a damned table
+     here.  If you just put the rows and columns in the right order,
+     it'd look awfully regular.  We could simply walk the bpstat list
+     and choose the highest priority action we find, with a little
+     logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/
+     CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says
+     is messy anyway).  */
+
+  /* step_resume entries: a step resume breakpoint overrides another
+     breakpoint of signal handling (see comment in wait_for_inferior
+     at first PC_IN_SIGTRAMP where we set the step_resume breakpoint).  */
+  /* We handle the through_sigtramp_breakpoint the same way; having both
+     one of those and a step_resume_breakpoint is probably very rare (?).  */
+
+  static const enum bpstat_what_main_action
+    table[(int) class_last][(int) BPSTAT_WHAT_LAST] =
+  {
+  /*                              old action */
+  /*       kc    ss    sn    sgl    slr   clr    clrs   sr    ts   shl   shlr
+   */
+/*no_effect */
+    {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr},
+/*wp_silent */
+    {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
+/*wp_noisy */
+    {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
+/*bp_nostop */
+    {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr},
+/*bp_silent */
+    {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr},
+/*bp_noisy */
+    {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr},
+/*long_jump */
+    {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr},
+/*long_resume */
+    {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr},
+/*step_resume */
+    {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr},
+/*through_sig */
+    {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr},
+/*shlib */
+    {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr},
+/*catch_shlib */
+    {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr}
+  };
+
+#undef kc
+#undef ss
+#undef sn
+#undef sgl
+#undef slr
+#undef clr
+#undef clrs
+#undef err
+#undef sr
+#undef ts
+#undef shl
+#undef shlr
+  enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING;
+  struct bpstat_what retval;
+
+  retval.call_dummy = 0;
+  for (; bs != NULL; bs = bs->next)
+    {
+      enum class bs_class = no_effect;
+      if (bs->breakpoint_at == NULL)
+	/* I suspect this can happen if it was a momentary breakpoint
+	   which has since been deleted.  */
+	continue;
+      switch (bs->breakpoint_at->type)
+	{
+	case bp_none:
+	  continue;
+
+	case bp_breakpoint:
+	case bp_hardware_breakpoint:
+	case bp_until:
+	case bp_finish:
+	  if (bs->stop)
+	    {
+	      if (bs->print)
+		bs_class = bp_noisy;
+	      else
+		bs_class = bp_silent;
+	    }
+	  else
+	    bs_class = bp_nostop;
+	  break;
+	case bp_watchpoint:
+	case bp_hardware_watchpoint:
+	case bp_read_watchpoint:
+	case bp_access_watchpoint:
+	  if (bs->stop)
+	    {
+	      if (bs->print)
+		bs_class = wp_noisy;
+	      else
+		bs_class = wp_silent;
+	    }
+	  else
+	    /* There was a watchpoint, but we're not stopping. 
+	       This requires no further action.  */
+	    bs_class = no_effect;
+	  break;
+	case bp_longjmp:
+	  bs_class = long_jump;
+	  break;
+	case bp_longjmp_resume:
+	  bs_class = long_resume;
+	  break;
+	case bp_step_resume:
+	  if (bs->stop)
+	    {
+	      bs_class = step_resume;
+	    }
+	  else
+	    /* It is for the wrong frame.  */
+	    bs_class = bp_nostop;
+	  break;
+	case bp_through_sigtramp:
+	  bs_class = through_sig;
+	  break;
+	case bp_watchpoint_scope:
+	  bs_class = bp_nostop;
+	  break;
+	case bp_shlib_event:
+	  bs_class = shlib_event;
+	  break;
+	case bp_thread_event:
+	case bp_overlay_event:
+	  bs_class = bp_nostop;
+	  break;
+	case bp_catch_load:
+	case bp_catch_unload:
+	  /* Only if this catchpoint triggered should we cause the
+	     step-out-of-dld behaviour.  Otherwise, we ignore this
+	     catchpoint.  */
+	  if (bs->stop)
+	    bs_class = catch_shlib_event;
+	  else
+	    bs_class = no_effect;
+	  break;
+	case bp_catch_fork:
+	case bp_catch_vfork:
+	case bp_catch_exec:
+	  if (bs->stop)
+	    {
+	      if (bs->print)
+		bs_class = bp_noisy;
+	      else
+		bs_class = bp_silent;
+	    }
+	  else
+	    /* There was a catchpoint, but we're not stopping.  
+	       This requires no further action.  */
+	    bs_class = no_effect;
+	  break;
+	case bp_catch_catch:
+	  if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH)
+	    bs_class = bp_nostop;
+	  else if (bs->stop)
+	    bs_class = bs->print ? bp_noisy : bp_silent;
+	  break;
+	case bp_catch_throw:
+	  if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW)
+	    bs_class = bp_nostop;
+	  else if (bs->stop)
+	    bs_class = bs->print ? bp_noisy : bp_silent;
+	  break;
+	case bp_call_dummy:
+	  /* Make sure the action is stop (silent or noisy),
+	     so infrun.c pops the dummy frame.  */
+	  bs_class = bp_silent;
+	  retval.call_dummy = 1;
+	  break;
+	}
+      current_action = table[(int) bs_class][(int) current_action];
+    }
+  retval.main_action = current_action;
+  return retval;
+}
+
+/* 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 (void)
+{
+  struct breakpoint *b;
+  ALL_BREAKPOINTS (b)
+    if (b->enable_state == bp_enabled && b->type == bp_watchpoint)
+      return 1;
+  return 0;
+}
+
+/* Nonzero if there are enabled hardware watchpoints. */
+int
+bpstat_have_active_hw_watchpoints (void)
+{
+  struct breakpoint *b;
+  ALL_BREAKPOINTS (b)
+    if ((b->enable_state == bp_enabled) &&
+	(b->inserted) &&
+	((b->type == bp_hardware_watchpoint) ||
+	 (b->type == bp_read_watchpoint) ||
+	 (b->type == bp_access_watchpoint)))
+      return 1;
+  return 0;
+}
+
+
+/* Given a bpstat that records zero or more triggered eventpoints, this
+   function returns another bpstat which contains only the catchpoints
+   on that first list, if any. */
+void
+bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list)
+{
+  struct bpstats root_bs[1];
+  bpstat bs = root_bs;
+  struct breakpoint *ep;
+  char *dll_pathname;
+
+  bpstat_clear (cp_list);
+  root_bs->next = NULL;
+
+  for (; ep_list != NULL; ep_list = ep_list->next)
+    {
+      /* Is this eventpoint a catchpoint?  If not, ignore it. */
+      ep = ep_list->breakpoint_at;
+      if (ep == NULL)
+	break;
+      if ((ep->type != bp_catch_load) &&
+	  (ep->type != bp_catch_unload) &&
+	  (ep->type != bp_catch_catch) &&
+	  (ep->type != bp_catch_throw))		
+	/* pai: (temp) ADD fork/vfork here!!  */
+	continue;
+
+      /* Yes; add it to the list. */
+      bs = bpstat_alloc (ep, bs);
+      *bs = *ep_list;
+      bs->next = NULL;
+      bs = root_bs->next;
+
+#if defined(SOLIB_ADD)
+      /* Also, for each triggered catchpoint, tag it with the name of
+         the library that caused this trigger.  (We copy the name now,
+         because it's only guaranteed to be available NOW, when the
+         catchpoint triggers.  Clients who may wish to know the name
+         later must get it from the catchpoint itself.) */
+      if (ep->triggered_dll_pathname != NULL)
+	xfree (ep->triggered_dll_pathname);
+      if (ep->type == bp_catch_load)
+	dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
+	                 PIDGET (inferior_ptid));
+      else
+	dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
+	                 PIDGET (inferior_ptid));
+#else
+      dll_pathname = NULL;
+#endif
+      if (dll_pathname)
+	{
+	  ep->triggered_dll_pathname = (char *) 
+	    xmalloc (strlen (dll_pathname) + 1);
+	  strcpy (ep->triggered_dll_pathname, dll_pathname);
+	}
+      else
+	ep->triggered_dll_pathname = NULL;
+    }
+
+  *cp_list = bs;
+}
+
+/* Print B to gdb_stdout. */
+static void
+print_one_breakpoint (struct breakpoint *b,
+		      CORE_ADDR *last_addr)
+{
+  register struct command_line *l;
+  register struct symbol *sym;
+  struct ep_type_description
+    {
+      enum bptype type;
+      char *description;
+    };
+  static struct ep_type_description bptypes[] =
+  {
+    {bp_none, "?deleted?"},
+    {bp_breakpoint, "breakpoint"},
+    {bp_hardware_breakpoint, "hw breakpoint"},
+    {bp_until, "until"},
+    {bp_finish, "finish"},
+    {bp_watchpoint, "watchpoint"},
+    {bp_hardware_watchpoint, "hw watchpoint"},
+    {bp_read_watchpoint, "read watchpoint"},
+    {bp_access_watchpoint, "acc watchpoint"},
+    {bp_longjmp, "longjmp"},
+    {bp_longjmp_resume, "longjmp resume"},
+    {bp_step_resume, "step resume"},
+    {bp_through_sigtramp, "sigtramp"},
+    {bp_watchpoint_scope, "watchpoint scope"},
+    {bp_call_dummy, "call dummy"},
+    {bp_shlib_event, "shlib events"},
+    {bp_thread_event, "thread events"},
+    {bp_overlay_event, "overlay events"},
+    {bp_catch_load, "catch load"},
+    {bp_catch_unload, "catch unload"},
+    {bp_catch_fork, "catch fork"},
+    {bp_catch_vfork, "catch vfork"},
+    {bp_catch_exec, "catch exec"},
+    {bp_catch_catch, "catch catch"},
+    {bp_catch_throw, "catch throw"}
+  };
+  
+  static char *bpdisps[] =
+  {"del", "dstp", "dis", "keep"};
+  static char bpenables[] = "nynny";
+  char wrap_indent[80];
+  struct ui_stream *stb = ui_out_stream_new (uiout);
+  struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
+
+  annotate_record ();
+  ui_out_tuple_begin (uiout, "bkpt");
+
+  /* 1 */
+  annotate_field (0);
+  ui_out_field_int (uiout, "number", b->number);
+
+  /* 2 */
+  annotate_field (1);
+  if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
+      || ((int) b->type != bptypes[(int) b->type].type))
+    internal_error (__FILE__, __LINE__,
+		    "bptypes table does not describe type #%d.",
+		    (int) b->type);
+  ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
+
+  /* 3 */
+  annotate_field (2);
+  ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]);
+
+  /* 4 */
+  annotate_field (3);
+  ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
+  ui_out_spaces (uiout, 2);
+  
+  /* 5 and 6 */
+  strcpy (wrap_indent, "                           ");
+  if (addressprint)
+    {
+      if (TARGET_ADDR_BIT <= 32)
+	strcat (wrap_indent, "           ");
+      else
+	strcat (wrap_indent, "                   ");
+    }
+  switch (b->type)
+    {
+    case bp_none:
+      internal_error (__FILE__, __LINE__,
+		      "print_one_breakpoint: bp_none encountered\n");
+      break;
+
+    case bp_watchpoint:
+    case bp_hardware_watchpoint:
+    case bp_read_watchpoint:
+    case bp_access_watchpoint:
+      /* Field 4, the address, is omitted (which makes the columns
+	 not line up too nicely with the headers, but the effect
+	 is relatively readable).  */
+      if (addressprint)
+	ui_out_field_skip (uiout, "addr");
+      annotate_field (5);
+      print_expression (b->exp, stb->stream);
+      ui_out_field_stream (uiout, "what", stb);
+      break;
+      
+    case bp_catch_load:
+    case bp_catch_unload:
+      /* Field 4, the address, is omitted (which makes the columns
+	 not line up too nicely with the headers, but the effect
+	 is relatively readable).  */
+      if (addressprint)
+	ui_out_field_skip (uiout, "addr");
+      annotate_field (5);
+      if (b->dll_pathname == NULL)
+	{
+	  ui_out_field_string (uiout, "what", "<any library>");
+	  ui_out_spaces (uiout, 1);
+	}
+      else
+	{
+	  ui_out_text (uiout, "library \"");
+	  ui_out_field_string (uiout, "what", b->dll_pathname);
+	  ui_out_text (uiout, "\" ");
+	}
+      break;
+      
+    case bp_catch_fork:
+    case bp_catch_vfork:
+      /* Field 4, the address, is omitted (which makes the columns
+	 not line up too nicely with the headers, but the effect
+	 is relatively readable).  */
+      if (addressprint)
+	ui_out_field_skip (uiout, "addr");
+      annotate_field (5);
+      if (b->forked_inferior_pid != 0)
+	{
+	  ui_out_text (uiout, "process ");
+	  ui_out_field_int (uiout, "what", b->forked_inferior_pid);
+	  ui_out_spaces (uiout, 1);
+	}
+      
+    case bp_catch_exec:
+      /* Field 4, the address, is omitted (which makes the columns
+	 not line up too nicely with the headers, but the effect
+	 is relatively readable).  */
+      if (addressprint)
+	ui_out_field_skip (uiout, "addr");
+      annotate_field (5);
+      if (b->exec_pathname != NULL)
+	{
+	  ui_out_text (uiout, "program \"");
+	  ui_out_field_string (uiout, "what", b->exec_pathname);
+	  ui_out_text (uiout, "\" ");
+	}
+      break;
+
+    case bp_catch_catch:
+      /* Field 4, the address, is omitted (which makes the columns
+	 not line up too nicely with the headers, but the effect
+	 is relatively readable).  */
+      if (addressprint)
+	ui_out_field_skip (uiout, "addr");
+      annotate_field (5);
+      ui_out_field_string (uiout, "what", "exception catch");
+      ui_out_spaces (uiout, 1);
+      break;
+
+    case bp_catch_throw:
+      /* Field 4, the address, is omitted (which makes the columns
+	 not line up too nicely with the headers, but the effect
+	 is relatively readable).  */
+      if (addressprint)
+	ui_out_field_skip (uiout, "addr");
+      annotate_field (5);
+      ui_out_field_string (uiout, "what", "exception throw");
+      ui_out_spaces (uiout, 1);
+      break;
+      
+    case bp_breakpoint:
+    case bp_hardware_breakpoint:
+    case bp_until:
+    case bp_finish:
+    case bp_longjmp:
+    case bp_longjmp_resume:
+    case bp_step_resume:
+    case bp_through_sigtramp:
+    case bp_watchpoint_scope:
+    case bp_call_dummy:
+    case bp_shlib_event:
+    case bp_thread_event:
+    case bp_overlay_event:
+      if (addressprint)
+	{
+	  annotate_field (4);
+	  ui_out_field_core_addr (uiout, "addr", b->address);
+	}
+      annotate_field (5);
+      *last_addr = b->address;
+      if (b->source_file)
+	{
+	  sym = find_pc_sect_function (b->address, b->section);
+	  if (sym)
+	    {
+	      ui_out_text (uiout, "in ");
+	      ui_out_field_string (uiout, "func",
+				   SYMBOL_SOURCE_NAME (sym));
+	      ui_out_wrap_hint (uiout, wrap_indent);
+	      ui_out_text (uiout, " at ");
+	    }
+	  ui_out_field_string (uiout, "file", b->source_file);
+	  ui_out_text (uiout, ":");
+	  ui_out_field_int (uiout, "line", b->line_number);
+	}
+      else
+	{
+	  print_address_symbolic (b->address, stb->stream, demangle, "");
+	  ui_out_field_stream (uiout, "at", stb);
+	}
+      break;
+    }
+  
+  if (b->thread != -1)
+    {
+      /* FIXME: This seems to be redundant and lost here; see the
+	 "stop only in" line a little further down. */
+      ui_out_text (uiout, " thread ");
+      ui_out_field_int (uiout, "thread", b->thread);
+    }
+  
+  ui_out_text (uiout, "\n");
+  
+  if (b->frame)
+    {
+      annotate_field (6);
+      ui_out_text (uiout, "\tstop only in stack frame at ");
+      ui_out_field_core_addr (uiout, "frame", b->frame);
+      ui_out_text (uiout, "\n");
+    }
+  
+  if (b->cond)
+    {
+      annotate_field (7);
+      ui_out_text (uiout, "\tstop only if ");
+      print_expression (b->cond, stb->stream);
+      ui_out_field_stream (uiout, "cond", stb);
+      ui_out_text (uiout, "\n");
+    }
+  
+  if (b->thread != -1)
+    {
+      /* FIXME should make an annotation for this */
+      ui_out_text (uiout, "\tstop only in thread ");
+      ui_out_field_int (uiout, "thread", b->thread);
+      ui_out_text (uiout, "\n");
+    }
+  
+  if (show_breakpoint_hit_counts && b->hit_count)
+    {
+      /* FIXME should make an annotation for this */
+      if (ep_is_catchpoint (b))
+	ui_out_text (uiout, "\tcatchpoint");
+      else
+	ui_out_text (uiout, "\tbreakpoint");
+      ui_out_text (uiout, " already hit ");
+      ui_out_field_int (uiout, "times", b->hit_count);
+      if (b->hit_count == 1)
+	ui_out_text (uiout, " time\n");
+      else
+	ui_out_text (uiout, " times\n");
+    }
+  
+  /* Output the count also if it is zero, but only if this is
+     mi. FIXME: Should have a better test for this. */
+  if (ui_out_is_mi_like_p (uiout))
+    if (show_breakpoint_hit_counts && b->hit_count == 0)
+      ui_out_field_int (uiout, "times", b->hit_count);
+
+  if (b->ignore_count)
+    {
+      annotate_field (8);
+      ui_out_text (uiout, "\tignore next ");
+      ui_out_field_int (uiout, "ignore", b->ignore_count);
+      ui_out_text (uiout, " hits\n");
+    }
+  
+  if ((l = b->commands))
+    {
+      annotate_field (9);
+      ui_out_tuple_begin (uiout, "script");
+      print_command_lines (uiout, l, 4);
+      ui_out_tuple_end (uiout);
+    }
+  ui_out_tuple_end (uiout);
+  do_cleanups (old_chain);
+}
+
+struct captured_breakpoint_query_args
+  {
+    int bnum;
+  };
+
+static int
+do_captured_breakpoint_query (struct ui_out *uiout, void *data)
+{
+  struct captured_breakpoint_query_args *args = data;
+  register struct breakpoint *b;
+  CORE_ADDR dummy_addr = 0;
+  ALL_BREAKPOINTS (b)
+    {
+      if (args->bnum == b->number)
+	{
+	  print_one_breakpoint (b, &dummy_addr);
+	  return GDB_RC_OK;
+	}
+    }
+  return GDB_RC_NONE;
+}
+
+enum gdb_rc
+gdb_breakpoint_query (struct ui_out *uiout, int bnum)
+{
+  struct captured_breakpoint_query_args args;
+  args.bnum = bnum;
+  /* For the moment we don't trust print_one_breakpoint() to not throw
+     an error. */
+  return catch_exceptions (uiout, do_captured_breakpoint_query, &args,
+			   NULL, RETURN_MASK_ALL);
+}
+
+/* Return non-zero if B is user settable (breakpoints, watchpoints,
+   catchpoints, et.al.). */
+
+static int
+user_settable_breakpoint (const struct breakpoint *b)
+{
+  return (b->type == bp_breakpoint
+	  || b->type == bp_catch_load
+	  || b->type == bp_catch_unload
+	  || b->type == bp_catch_fork
+	  || b->type == bp_catch_vfork
+	  || b->type == bp_catch_exec
+	  || b->type == bp_catch_catch
+	  || b->type == bp_catch_throw
+	  || b->type == bp_hardware_breakpoint
+	  || b->type == bp_watchpoint
+	  || b->type == bp_read_watchpoint
+	  || b->type == bp_access_watchpoint
+	  || b->type == bp_hardware_watchpoint);
+}
+	
+/* Print information on user settable breakpoint (watchpoint, etc)
+   number BNUM.  If BNUM is -1 print all user settable breakpoints.
+   If ALLFLAG is non-zero, include non- user settable breakpoints. */
+
+static void
+breakpoint_1 (int bnum, int allflag)
+{
+  register struct breakpoint *b;
+  CORE_ADDR last_addr = (CORE_ADDR) -1;
+  int nr_printable_breakpoints;
+  
+  /* Compute the number of rows in the table. */
+  nr_printable_breakpoints = 0;
+  ALL_BREAKPOINTS (b)
+    if (bnum == -1
+	|| bnum == b->number)
+      {
+	if (allflag || user_settable_breakpoint (b))
+	  nr_printable_breakpoints++;
+      }
+
+  if (addressprint)
+    ui_out_table_begin (uiout, 6, nr_printable_breakpoints, "BreakpointTable");
+  else
+    ui_out_table_begin (uiout, 5, nr_printable_breakpoints, "BreakpointTable");
+
+  if (nr_printable_breakpoints > 0)
+    annotate_breakpoints_headers ();
+  if (nr_printable_breakpoints > 0)
+    annotate_field (0);
+  ui_out_table_header (uiout, 3, ui_left, "number", "Num");		/* 1 */
+  if (nr_printable_breakpoints > 0)
+    annotate_field (1);
+  ui_out_table_header (uiout, 14, ui_left, "type", "Type");		/* 2 */
+  if (nr_printable_breakpoints > 0)
+    annotate_field (2);
+  ui_out_table_header (uiout, 4, ui_left, "disp", "Disp");		/* 3 */
+  if (nr_printable_breakpoints > 0)
+    annotate_field (3);
+  ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");	/* 4 */
+  if (addressprint)
+	{
+	  if (nr_printable_breakpoints > 0)
+	    annotate_field (4);
+	  if (TARGET_ADDR_BIT <= 32)
+	    ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
+	  else
+	    ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
+	}
+  if (nr_printable_breakpoints > 0)
+    annotate_field (5);
+  ui_out_table_header (uiout, 40, ui_noalign, "what", "What");	/* 6 */
+  ui_out_table_body (uiout);
+  if (nr_printable_breakpoints > 0)
+    annotate_breakpoints_table ();
+
+  ALL_BREAKPOINTS (b)
+    if (bnum == -1
+	|| bnum == b->number)
+      {
+	/* We only print out user settable breakpoints unless the
+	   allflag is set. */
+	if (allflag || user_settable_breakpoint (b))
+	  print_one_breakpoint (b, &last_addr);
+      }
+  
+  ui_out_table_end (uiout);
+
+  if (nr_printable_breakpoints == 0)
+    {
+      if (bnum == -1)
+	ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n");
+      else
+	ui_out_message (uiout, 0, "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);
+    }
+
+  /* FIXME? Should this be moved up so that it is only called when
+     there have been breakpoints? */
+  annotate_breakpoints_table_end ();
+}
+
+/* ARGSUSED */
+static void
+breakpoints_info (char *bnum_exp, int from_tty)
+{
+  int bnum = -1;
+
+  if (bnum_exp)
+    bnum = parse_and_eval_long (bnum_exp);
+
+  breakpoint_1 (bnum, 0);
+}
+
+/* ARGSUSED */
+static void
+maintenance_info_breakpoints (char *bnum_exp, int from_tty)
+{
+  int bnum = -1;
+
+  if (bnum_exp)
+    bnum = parse_and_eval_long (bnum_exp);
+
+  breakpoint_1 (bnum, 1);
+}
+
+/* Print a message describing any breakpoints set at PC.  */
+
+static void
+describe_other_breakpoints (CORE_ADDR pc, asection *section)
+{
+  register int others = 0;
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->address == pc)	/* address match / overlay match */
+      if (!overlay_debugging || b->section == section)
+	others++;
+  if (others > 0)
+    {
+      printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : "");
+      ALL_BREAKPOINTS (b)
+	if (b->address == pc)	/* address match / overlay match */
+	  if (!overlay_debugging || b->section == section)
+	    {
+	      others--;
+	      printf_filtered ("%d%s%s ",
+			       b->number,
+			       ((b->enable_state == bp_disabled || 
+				 b->enable_state == bp_shlib_disabled || 
+				 b->enable_state == bp_call_disabled) 
+				? " (disabled)" 
+				: b->enable_state == bp_permanent 
+				? " (permanent)"
+				: ""),
+			       (others > 1) ? "," 
+			       : ((others == 1) ? " and" : ""));
+	    }
+      printf_filtered ("also set at pc ");
+      print_address_numeric (pc, 1, gdb_stdout);
+      printf_filtered (".\n");
+    }
+}
+
+/* Set the default place to put a breakpoint
+   for the `break' command with no arguments.  */
+
+void
+set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab,
+			int line)
+{
+  default_breakpoint_valid = valid;
+  default_breakpoint_address = addr;
+  default_breakpoint_symtab = symtab;
+  default_breakpoint_line = line;
+}
+
+/* Return true iff it is meaningful to use the address member of
+   BPT.  For some breakpoint types, the address member is irrelevant
+   and it makes no sense to attempt to compare it to other addresses
+   (or use it for any other purpose either).
+
+   More specifically, each of the following breakpoint types will always
+   have a zero valued address and we don't want check_duplicates() to mark
+   breakpoints of any of these types to be a duplicate of an actual
+   breakpoint at address zero:
+
+      bp_watchpoint
+      bp_hardware_watchpoint
+      bp_read_watchpoint
+      bp_access_watchpoint
+      bp_catch_exec
+      bp_longjmp_resume
+      bp_catch_fork
+      bp_catch_vork */
+
+static int
+breakpoint_address_is_meaningful (struct breakpoint *bpt)
+{
+  enum bptype type = bpt->type;
+
+  return (type != bp_watchpoint
+	  && type != bp_hardware_watchpoint
+	  && type != bp_read_watchpoint
+	  && type != bp_access_watchpoint
+	  && type != bp_catch_exec
+	  && type != bp_longjmp_resume
+	  && type != bp_catch_fork
+	  && type != bp_catch_vfork);
+}
+
+/* Rescan breakpoints at the same address and section as BPT,
+   marking the first one as "first" and any others as "duplicates".
+   This is so that the bpt instruction is only inserted once.
+   If we have a permanent breakpoint at the same place as BPT, make
+   that one the official one, and the rest as duplicates.  */
+
+static void
+check_duplicates (struct breakpoint *bpt)
+{
+  register struct breakpoint *b;
+  register int count = 0;
+  struct breakpoint *perm_bp = 0;
+  CORE_ADDR address = bpt->address;
+  asection *section = bpt->section;
+
+  if (! breakpoint_address_is_meaningful (bpt))
+    return;
+
+  ALL_BREAKPOINTS (b)
+    if (b->enable_state != bp_disabled
+	&& b->enable_state != bp_shlib_disabled
+	&& b->enable_state != bp_call_disabled
+	&& b->address == address	/* address / overlay match */
+	&& (!overlay_debugging || b->section == section)
+	&& breakpoint_address_is_meaningful (b))
+    {
+      /* Have we found a permanent breakpoint?  */
+      if (b->enable_state == bp_permanent)
+	{
+	  perm_bp = b;
+	  break;
+	}
+	
+      count++;
+      b->duplicate = count > 1;
+    }
+
+  /* If we found a permanent breakpoint at this address, go over the
+     list again and declare all the other breakpoints there to be the
+     duplicates.  */
+  if (perm_bp)
+    {
+      perm_bp->duplicate = 0;
+
+      /* Permanent breakpoint should always be inserted.  */
+      if (! perm_bp->inserted)
+	internal_error (__FILE__, __LINE__,
+			"allegedly permanent breakpoint is not "
+			"actually inserted");
+
+      ALL_BREAKPOINTS (b)
+	if (b != perm_bp)
+	  {
+	    if (b->inserted)
+	      internal_error (__FILE__, __LINE__,
+			      "another breakpoint was inserted on top of "
+			      "a permanent breakpoint");
+
+	    if (b->enable_state != bp_disabled
+		&& b->enable_state != bp_shlib_disabled
+		&& b->enable_state != bp_call_disabled
+		&& b->address == address	/* address / overlay match */
+		&& (!overlay_debugging || b->section == section)
+		&& breakpoint_address_is_meaningful (b))
+	      b->duplicate = 1;
+	  }
+    }
+}
+
+/* set_raw_breakpoint() is a low level routine for allocating and
+   partially initializing a breakpoint of type BPTYPE.  The newly
+   created breakpoint's address, section, source file name, and line
+   number are provided by SAL.  The newly created and partially
+   initialized breakpoint is added to the breakpoint chain and
+   is also returned as the value of this function.
+
+   It is expected that the caller will complete the initialization of
+   the newly created breakpoint struct as well as output any status
+   information regarding the creation of a new breakpoint.  In
+   particular, set_raw_breakpoint() does NOT set the breakpoint
+   number!  Care should be taken to not allow an error() to occur
+   prior to completing the initialization of the breakpoint.  If this
+   should happen, a bogus breakpoint will be left on the chain.  */
+
+struct breakpoint *
+set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
+{
+  register struct breakpoint *b, *b1;
+
+  b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
+  memset (b, 0, sizeof (*b));
+  b->address = sal.pc;
+  if (sal.symtab == NULL)
+    b->source_file = NULL;
+  else
+    b->source_file = savestring (sal.symtab->filename,
+				 strlen (sal.symtab->filename));
+  b->section = sal.section;
+  b->type = bptype;
+  b->language = current_language->la_language;
+  b->input_radix = input_radix;
+  b->thread = -1;
+  b->line_number = sal.line;
+  b->enable_state = bp_enabled;
+  b->next = 0;
+  b->silent = 0;
+  b->ignore_count = 0;
+  b->commands = NULL;
+  b->frame = 0;
+  b->dll_pathname = NULL;
+  b->triggered_dll_pathname = NULL;
+  b->forked_inferior_pid = 0;
+  b->exec_pathname = NULL;
+
+  /* Add this breakpoint to the end of the chain
+     so that a list of breakpoints will come out in order
+     of increasing numbers.  */
+
+  b1 = breakpoint_chain;
+  if (b1 == 0)
+    breakpoint_chain = b;
+  else
+    {
+      while (b1->next)
+	b1 = b1->next;
+      b1->next = b;
+    }
+
+  check_duplicates (b);
+  breakpoints_changed ();
+
+  return b;
+}
+
+
+/* Note that the breakpoint object B describes a permanent breakpoint
+   instruction, hard-wired into the inferior's code.  */
+void
+make_breakpoint_permanent (struct breakpoint *b)
+{
+  b->enable_state = bp_permanent;
+
+  /* By definition, permanent breakpoints are already present in the code.  */
+  b->inserted = 1;
+}
+
+static struct breakpoint *
+create_internal_breakpoint (CORE_ADDR address, enum bptype type)
+{
+  static int internal_breakpoint_number = -1;
+  struct symtab_and_line sal;
+  struct breakpoint *b;
+
+  INIT_SAL (&sal);		/* initialize to zeroes */
+
+  sal.pc = address;
+  sal.section = find_pc_overlay (sal.pc);
+
+  b = set_raw_breakpoint (sal, type);
+  b->number = internal_breakpoint_number--;
+  b->disposition = disp_donttouch;
+
+  return b;
+}
+
+
+static void
+create_longjmp_breakpoint (char *func_name)
+{
+  struct breakpoint *b;
+  struct minimal_symbol *m;
+
+  if (func_name == NULL)
+    b = create_internal_breakpoint (0, bp_longjmp_resume);
+  else
+    {
+      if ((m = lookup_minimal_symbol_text (func_name, NULL, NULL)) == NULL)
+	return;
+ 
+      b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp);
+    }
+
+  b->enable_state = bp_disabled;
+  b->silent = 1;
+  if (func_name)
+    b->addr_string = xstrdup (func_name);
+}
+
+/* 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 (void)
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->type == bp_longjmp)
+    {
+      b->enable_state = bp_enabled;
+      check_duplicates (b);
+    }
+}
+
+void
+disable_longjmp_breakpoint (void)
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->type == bp_longjmp
+	|| b->type == bp_longjmp_resume)
+    {
+      b->enable_state = bp_disabled;
+      check_duplicates (b);
+    }
+}
+
+static void
+create_overlay_event_breakpoint (char *func_name)
+{
+  struct breakpoint *b;
+  struct minimal_symbol *m;
+
+  if ((m = lookup_minimal_symbol_text (func_name, NULL, NULL)) == NULL)
+    return;
+ 
+  b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), 
+				  bp_overlay_event);
+  b->addr_string = xstrdup (func_name);
+
+  if (overlay_debugging == ovly_auto)
+    {
+      b->enable_state = bp_enabled;
+      overlay_events_enabled = 1;
+    }
+  else 
+    {
+      b->enable_state = bp_disabled;
+      overlay_events_enabled = 0;
+    }
+}
+
+void
+enable_overlay_breakpoints (void)
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->type == bp_overlay_event)
+    {
+      b->enable_state = bp_enabled;
+      check_duplicates (b);
+      overlay_events_enabled = 1;
+    }
+}
+
+void
+disable_overlay_breakpoints (void)
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->type == bp_overlay_event)
+    {
+      b->enable_state = bp_disabled;
+      check_duplicates (b);
+      overlay_events_enabled = 0;
+    }
+}
+
+struct breakpoint *
+create_thread_event_breakpoint (CORE_ADDR address)
+{
+  struct breakpoint *b;
+  char addr_string[80];		/* Surely an addr can't be longer than that. */
+
+  b = create_internal_breakpoint (address, bp_thread_event);
+  
+  b->enable_state = bp_enabled;
+  /* addr_string has to be used or breakpoint_re_set will delete me.  */
+  sprintf (addr_string, "*0x%s", paddr (b->address));
+  b->addr_string = xstrdup (addr_string);
+
+  return b;
+}
+
+void
+remove_thread_event_breakpoints (void)
+{
+  struct breakpoint *b, *temp;
+
+  ALL_BREAKPOINTS_SAFE (b, temp)
+    if (b->type == bp_thread_event)
+      delete_breakpoint (b);
+}
+
+#ifdef SOLIB_ADD
+void
+remove_solib_event_breakpoints (void)
+{
+  register struct breakpoint *b, *temp;
+
+  ALL_BREAKPOINTS_SAFE (b, temp)
+    if (b->type == bp_shlib_event)
+      delete_breakpoint (b);
+}
+
+struct breakpoint *
+create_solib_event_breakpoint (CORE_ADDR address)
+{
+  struct breakpoint *b;
+
+  b = create_internal_breakpoint (address, bp_shlib_event);
+  return b;
+}
+
+/* Disable any breakpoints that are on code in shared libraries.  Only
+   apply to enabled breakpoints, disabled ones can just stay disabled.  */
+
+void
+disable_breakpoints_in_shlibs (int silent)
+{
+  struct breakpoint *b;
+  int disabled_shlib_breaks = 0;
+
+  /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */
+  ALL_BREAKPOINTS (b)
+  {
+#if defined (PC_SOLIB)
+    if (((b->type == bp_breakpoint) ||
+	 (b->type == bp_hardware_breakpoint)) &&
+	b->enable_state == bp_enabled &&
+	!b->duplicate &&
+	PC_SOLIB (b->address))
+      {
+	b->enable_state = bp_shlib_disabled;
+	if (!silent)
+	  {
+	    if (!disabled_shlib_breaks)
+	      {
+		target_terminal_ours_for_output ();
+		warning ("Temporarily disabling shared library breakpoints:");
+	      }
+	    disabled_shlib_breaks = 1;
+	    warning ("breakpoint #%d ", b->number);
+	  }
+      }
+#endif
+  }
+}
+
+/* Try to reenable any breakpoints in shared libraries.  */
+void
+re_enable_breakpoints_in_shlibs (void)
+{
+  struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->enable_state == bp_shlib_disabled)
+    {
+      char buf[1];
+
+      /* Do not reenable the breakpoint if the shared library
+         is still not mapped in.  */
+      if (target_read_memory (b->address, buf, 1) == 0)
+	b->enable_state = bp_enabled;
+    }
+}
+
+#endif
+
+static void
+solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname,
+		     char *cond_string, enum bptype bp_kind)
+{
+  struct breakpoint *b;
+  struct symtabs_and_lines sals;
+  struct cleanup *old_chain;
+  struct cleanup *canonical_strings_chain = NULL;
+  char *addr_start = hookname;
+  char *addr_end = NULL;
+  char **canonical = (char **) NULL;
+  int thread = -1;		/* All threads. */
+
+  /* Set a breakpoint on the specified hook. */
+  sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical);
+  addr_end = hookname;
+
+  if (sals.nelts == 0)
+    {
+      warning ("Unable to set a breakpoint on dynamic linker callback.");
+      warning ("Suggest linking with /opt/langtools/lib/end.o.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      return;
+    }
+  if (sals.nelts != 1)
+    {
+      warning ("Unable to set unique breakpoint on dynamic linker callback.");
+      warning ("GDB will be unable to track shl_load/shl_unload calls");
+      return;
+    }
+
+  /* Make sure that all storage allocated in decode_line_1 gets freed
+     in case the following errors out.  */
+  old_chain = make_cleanup (xfree, sals.sals);
+  if (canonical != (char **) NULL)
+    {
+      make_cleanup (xfree, canonical);
+      canonical_strings_chain = make_cleanup (null_cleanup, 0);
+      if (canonical[0] != NULL)
+	make_cleanup (xfree, canonical[0]);
+    }
+
+  resolve_sal_pc (&sals.sals[0]);
+
+  /* Remove the canonical strings from the cleanup, they are needed below.  */
+  if (canonical != (char **) NULL)
+    discard_cleanups (canonical_strings_chain);
+
+  b = set_raw_breakpoint (sals.sals[0], bp_kind);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->cond = NULL;
+  b->cond_string = (cond_string == NULL) ? 
+    NULL : savestring (cond_string, strlen (cond_string));
+  b->thread = thread;
+
+  if (canonical != (char **) NULL && canonical[0] != NULL)
+    b->addr_string = canonical[0];
+  else if (addr_start)
+    b->addr_string = savestring (addr_start, addr_end - addr_start);
+
+  b->enable_state = bp_enabled;
+  b->disposition = tempflag ? disp_del : disp_donttouch;
+
+  if (dll_pathname == NULL)
+    b->dll_pathname = NULL;
+  else
+    {
+      b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
+      strcpy (b->dll_pathname, dll_pathname);
+    }
+
+  mention (b);
+  do_cleanups (old_chain);
+}
+
+void
+create_solib_load_event_breakpoint (char *hookname, int tempflag,
+				    char *dll_pathname, char *cond_string)
+{
+  solib_load_unload_1 (hookname, tempflag, dll_pathname, 
+		       cond_string, bp_catch_load);
+}
+
+void
+create_solib_unload_event_breakpoint (char *hookname, int tempflag,
+				      char *dll_pathname, char *cond_string)
+{
+  solib_load_unload_1 (hookname,tempflag, dll_pathname, 
+		       cond_string, bp_catch_unload);
+}
+
+static void
+create_fork_vfork_event_catchpoint (int tempflag, char *cond_string,
+				    enum bptype bp_kind)
+{
+  struct symtab_and_line sal;
+  struct breakpoint *b;
+  int thread = -1;		/* All threads. */
+
+  INIT_SAL (&sal);
+  sal.pc = 0;
+  sal.symtab = NULL;
+  sal.line = 0;
+
+  b = set_raw_breakpoint (sal, bp_kind);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->cond = NULL;
+  b->cond_string = (cond_string == NULL) ? 
+    NULL : savestring (cond_string, strlen (cond_string));
+  b->thread = thread;
+  b->addr_string = NULL;
+  b->enable_state = bp_enabled;
+  b->disposition = tempflag ? disp_del : disp_donttouch;
+  b->forked_inferior_pid = 0;
+
+  mention (b);
+}
+
+void
+create_fork_event_catchpoint (int tempflag, char *cond_string)
+{
+  create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork);
+}
+
+void
+create_vfork_event_catchpoint (int tempflag, char *cond_string)
+{
+  create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork);
+}
+
+void
+create_exec_event_catchpoint (int tempflag, char *cond_string)
+{
+  struct symtab_and_line sal;
+  struct breakpoint *b;
+  int thread = -1;		/* All threads. */
+
+  INIT_SAL (&sal);
+  sal.pc = 0;
+  sal.symtab = NULL;
+  sal.line = 0;
+
+  b = set_raw_breakpoint (sal, bp_catch_exec);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->cond = NULL;
+  b->cond_string = (cond_string == NULL) ?
+    NULL : savestring (cond_string, strlen (cond_string));
+  b->thread = thread;
+  b->addr_string = NULL;
+  b->enable_state = bp_enabled;
+  b->disposition = tempflag ? disp_del : disp_donttouch;
+
+  mention (b);
+}
+
+static int
+hw_breakpoint_used_count (void)
+{
+  register struct breakpoint *b;
+  int i = 0;
+
+  ALL_BREAKPOINTS (b)
+  {
+    if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
+      i++;
+  }
+
+  return i;
+}
+
+static int
+hw_watchpoint_used_count (enum bptype type, int *other_type_used)
+{
+  register struct breakpoint *b;
+  int i = 0;
+
+  *other_type_used = 0;
+  ALL_BREAKPOINTS (b)
+  {
+    if (b->enable_state == bp_enabled)
+      {
+	if (b->type == type)
+	  i++;
+	else if ((b->type == bp_hardware_watchpoint ||
+		  b->type == bp_read_watchpoint ||
+		  b->type == bp_access_watchpoint)
+		 && b->enable_state == bp_enabled)
+	  *other_type_used = 1;
+      }
+  }
+  return i;
+}
+
+/* Call this after hitting the longjmp() breakpoint.  Use this to set
+   a new breakpoint at the target of the jmp_buf.
+
+   FIXME - This ought to be done by setting a temporary breakpoint
+   that gets deleted automatically... */
+
+void
+set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_info *frame)
+{
+  register struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    if (b->type == bp_longjmp_resume)
+    {
+      b->address = pc;
+      b->enable_state = bp_enabled;
+      if (frame != NULL)
+	b->frame = frame->frame;
+      else
+	b->frame = 0;
+      check_duplicates (b);
+      return;
+    }
+}
+
+void
+disable_watchpoints_before_interactive_call_start (void)
+{
+  struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+  {
+    if (((b->type == bp_watchpoint)
+	 || (b->type == bp_hardware_watchpoint)
+	 || (b->type == bp_read_watchpoint)
+	 || (b->type == bp_access_watchpoint)
+	 || ep_is_exception_catchpoint (b))
+	&& (b->enable_state == bp_enabled))
+      {
+	b->enable_state = bp_call_disabled;
+	check_duplicates (b);
+      }
+  }
+}
+
+void
+enable_watchpoints_after_interactive_call_stop (void)
+{
+  struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+  {
+    if (((b->type == bp_watchpoint)
+	 || (b->type == bp_hardware_watchpoint)
+	 || (b->type == bp_read_watchpoint)
+	 || (b->type == bp_access_watchpoint)
+	 || ep_is_exception_catchpoint (b))
+	&& (b->enable_state == bp_call_disabled))
+      {
+	b->enable_state = bp_enabled;
+	check_duplicates (b);
+      }
+  }
+}
+
+
+/* Set a breakpoint that will evaporate an end of command
+   at address specified by SAL.
+   Restrict it to frame FRAME if FRAME is nonzero.  */
+
+struct breakpoint *
+set_momentary_breakpoint (struct symtab_and_line sal, struct frame_info *frame,
+			  enum bptype type)
+{
+  register struct breakpoint *b;
+  b = set_raw_breakpoint (sal, type);
+  b->enable_state = bp_enabled;
+  b->disposition = disp_donttouch;
+  b->frame = (frame ? frame->frame : 0);
+
+  /* If we're debugging a multi-threaded program, then we
+     want momentary breakpoints to be active in only a 
+     single thread of control.  */
+  if (in_thread_list (inferior_ptid))
+    b->thread = pid_to_thread_id (inferior_ptid);
+
+  return b;
+}
+
+
+/* Tell the user we have just set a breakpoint B.  */
+
+static void
+mention (struct breakpoint *b)
+{
+  int say_where = 0;
+  struct cleanup *old_chain;
+  struct ui_stream *stb;
+
+  stb = ui_out_stream_new (uiout);
+  old_chain = make_cleanup_ui_out_stream_delete (stb);
+
+  /* FIXME: This is misplaced; mention() is called by things (like hitting a
+     watchpoint) other than breakpoint creation.  It should be possible to
+     clean this up and at the same time replace the random calls to
+     breakpoint_changed with this hook, as has already been done for
+     delete_breakpoint_hook and so on.  */
+  if (create_breakpoint_hook)
+    create_breakpoint_hook (b);
+  breakpoint_create_event (b->number);
+
+  switch (b->type)
+    {
+    case bp_none:
+      printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number);
+      break;
+    case bp_watchpoint:
+      ui_out_text (uiout, "Watchpoint ");
+      ui_out_tuple_begin (uiout, "wpt");
+      ui_out_field_int (uiout, "number", b->number);
+      ui_out_text (uiout, ": ");
+      print_expression (b->exp, stb->stream);
+      ui_out_field_stream (uiout, "exp", stb);
+      ui_out_tuple_end (uiout);
+      break;
+    case bp_hardware_watchpoint:
+      ui_out_text (uiout, "Hardware watchpoint ");
+      ui_out_tuple_begin (uiout, "wpt");
+      ui_out_field_int (uiout, "number", b->number);
+      ui_out_text (uiout, ": ");
+      print_expression (b->exp, stb->stream);
+      ui_out_field_stream (uiout, "exp", stb);
+      ui_out_tuple_end (uiout);
+      break;
+    case bp_read_watchpoint:
+      ui_out_text (uiout, "Hardware read watchpoint ");
+      ui_out_tuple_begin (uiout, "hw-rwpt");
+      ui_out_field_int (uiout, "number", b->number);
+      ui_out_text (uiout, ": ");
+      print_expression (b->exp, stb->stream);
+      ui_out_field_stream (uiout, "exp", stb);
+      ui_out_tuple_end (uiout);
+      break;
+    case bp_access_watchpoint:
+      ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
+      ui_out_tuple_begin (uiout, "hw-awpt");
+      ui_out_field_int (uiout, "number", b->number);
+      ui_out_text (uiout, ": ");
+      print_expression (b->exp, stb->stream);
+      ui_out_field_stream (uiout, "exp", stb);
+      ui_out_tuple_end (uiout);
+      break;
+    case bp_breakpoint:
+      if (ui_out_is_mi_like_p (uiout))
+	{
+	  say_where = 0;
+	  break;
+	}
+      printf_filtered ("Breakpoint %d", b->number);
+      say_where = 1;
+      break;
+    case bp_hardware_breakpoint:
+      if (ui_out_is_mi_like_p (uiout))
+	{
+	  say_where = 0;
+	  break;
+	}
+      printf_filtered ("Hardware assisted breakpoint %d", b->number);
+      say_where = 1;
+      break;
+    case bp_catch_load:
+    case bp_catch_unload:
+      printf_filtered ("Catchpoint %d (%s %s)",
+		       b->number,
+		       (b->type == bp_catch_load) ? "load" : "unload",
+		       (b->dll_pathname != NULL) ? 
+		       b->dll_pathname : "<any library>");
+      break;
+    case bp_catch_fork:
+    case bp_catch_vfork:
+      printf_filtered ("Catchpoint %d (%s)",
+		       b->number,
+		       (b->type == bp_catch_fork) ? "fork" : "vfork");
+      break;
+    case bp_catch_exec:
+      printf_filtered ("Catchpoint %d (exec)",
+		       b->number);
+      break;
+    case bp_catch_catch:
+    case bp_catch_throw:
+      printf_filtered ("Catchpoint %d (%s)",
+		       b->number,
+		       (b->type == bp_catch_catch) ? "catch" : "throw");
+      break;
+
+    case bp_until:
+    case bp_finish:
+    case bp_longjmp:
+    case bp_longjmp_resume:
+    case bp_step_resume:
+    case bp_through_sigtramp:
+    case bp_call_dummy:
+    case bp_watchpoint_scope:
+    case bp_shlib_event:
+    case bp_thread_event:
+    case bp_overlay_event:
+      break;
+    }
+  if (say_where)
+    {
+      if (addressprint || b->source_file == NULL)
+	{
+	  printf_filtered (" at ");
+	  print_address_numeric (b->address, 1, gdb_stdout);
+	}
+      if (b->source_file)
+	printf_filtered (": file %s, line %d.",
+			 b->source_file, b->line_number);
+    }
+  do_cleanups (old_chain);
+  if (ui_out_is_mi_like_p (uiout))
+    return;
+  printf_filtered ("\n");
+}
+
+
+/* Add SALS.nelts breakpoints to the breakpoint table.  For each
+   SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i],
+   COND[i] and COND_STRING[i] values.
+
+   NOTE: If the function succeeds, the caller is expected to cleanup
+   the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the
+   array contents).  If the function fails (error() is called), the
+   caller is expected to cleanups both the ADDR_STRING, COND_STRING,
+   COND and SALS arrays and each of those arrays contents. */
+
+static void
+create_breakpoints (struct symtabs_and_lines sals, char **addr_string,
+		    struct expression **cond, char **cond_string,
+		    enum bptype type, enum bpdisp disposition,
+		    int thread, int ignore_count, int from_tty)
+{
+  if (type == bp_hardware_breakpoint)
+    {
+      int i = hw_breakpoint_used_count ();
+      int target_resources_ok = 
+	TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint, 
+					    i + sals.nelts, 0);
+      if (target_resources_ok == 0)
+	error ("No hardware breakpoint support in the target.");
+      else if (target_resources_ok < 0)
+	error ("Hardware breakpoints used exceeds limit.");
+    }
+
+  /* Now set all the breakpoints.  */
+  {
+    int i;
+    for (i = 0; i < sals.nelts; i++)
+      {
+	struct breakpoint *b;
+	struct symtab_and_line sal = sals.sals[i];
+
+	if (from_tty)
+	  describe_other_breakpoints (sal.pc, sal.section);
+	
+	b = set_raw_breakpoint (sal, type);
+	set_breakpoint_count (breakpoint_count + 1);
+	b->number = breakpoint_count;
+	b->cond = cond[i];
+	b->thread = thread;
+	b->addr_string = addr_string[i];
+	b->cond_string = cond_string[i];
+	b->ignore_count = ignore_count;
+	b->enable_state = bp_enabled;
+	b->disposition = disposition;
+	mention (b);
+      }
+  }    
+}
+
+/* Parse ARG which is assumed to be a SAL specification possibly
+   followed by conditionals.  On return, SALS contains an array of SAL
+   addresses found. ADDR_STRING contains a vector of (canonical)
+   address strings. ARG points to the end of the SAL. */
+
+void
+parse_breakpoint_sals (char **address,
+		       struct symtabs_and_lines *sals,
+		       char ***addr_string)
+{
+  char *addr_start = *address;
+  *addr_string = NULL;
+  /* If no arg given, or if first arg is 'if ', use the default
+     breakpoint. */
+  if ((*address) == NULL
+      || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
+    {
+      if (default_breakpoint_valid)
+	{
+	  struct symtab_and_line sal;
+	  INIT_SAL (&sal);		/* initialize to zeroes */
+	  sals->sals = (struct symtab_and_line *)
+	    xmalloc (sizeof (struct symtab_and_line));
+	  sal.pc = default_breakpoint_address;
+	  sal.line = default_breakpoint_line;
+	  sal.symtab = default_breakpoint_symtab;
+	  sal.section = find_pc_overlay (sal.pc);
+	  sals->sals[0] = sal;
+	  sals->nelts = 1;
+	}
+      else
+	error ("No default breakpoint address now.");
+    }
+  else
+    {
+      /* Force almost all breakpoints to be in terms of the
+         current_source_symtab (which is decode_line_1's default).  This
+         should produce the results we want almost all of the time while
+         leaving default_breakpoint_* alone.  */
+	 
+      struct symtab_and_line cursal = 
+      			get_current_or_default_source_symtab_and_line ();
+			
+      if (default_breakpoint_valid
+	  && (!cursal.symtab
+	      || (strchr ("+-", (*address)[0]) != NULL)))
+	*sals = decode_line_1 (address, 1, default_breakpoint_symtab,
+			       default_breakpoint_line, addr_string);
+      else
+	*sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0, addr_string);
+    }
+  /* For any SAL that didn't have a canonical string, fill one in. */
+  if (sals->nelts > 0 && *addr_string == NULL)
+    *addr_string = xcalloc (sals->nelts, sizeof (char **));
+  if (addr_start != (*address))
+    {
+      int i;
+      for (i = 0; i < sals->nelts; i++)
+	{
+	  /* Add the string if not present. */
+	  if ((*addr_string)[i] == NULL)
+	    (*addr_string)[i] = savestring (addr_start, (*address) - addr_start);
+	}
+    }
+}
+
+
+/* Convert each SAL into a real PC.  Verify that the PC can be
+   inserted as a breakpoint.  If it can't throw an error. */
+
+void
+breakpoint_sals_to_pc (struct symtabs_and_lines *sals,
+		       char *address)
+{    
+  int i;
+  for (i = 0; i < sals->nelts; i++)
+    {
+      resolve_sal_pc (&sals->sals[i]);
+
+      /* It's possible for the PC to be nonzero, but still an illegal
+         value on some targets.
+
+         For example, on HP-UX if you start gdb, and before running the
+         inferior you try to set a breakpoint on a shared library function
+         "foo" where the inferior doesn't call "foo" directly but does
+         pass its address to another function call, then we do find a
+         minimal symbol for the "foo", but it's address is invalid.
+         (Appears to be an index into a table that the loader sets up
+         when the inferior is run.)
+
+         Give the target a chance to bless sals.sals[i].pc before we
+         try to make a breakpoint for it. */
+      if (PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc))
+	{
+	  if (address == NULL)
+	    error ("Cannot break without a running program.");
+	  else
+	    error ("Cannot break on %s without a running program.", 
+		   address);
+	}
+    }
+}
+
+/* Set a breakpoint according to ARG (function, linenum or *address)
+   flag: first bit  : 0 non-temporary, 1 temporary.
+   second bit : 0 normal breakpoint, 1 hardware breakpoint. */
+
+static void
+break_command_1 (char *arg, int flag, int from_tty)
+{
+  int tempflag, hardwareflag;
+  struct symtabs_and_lines sals;
+  register struct expression **cond = 0;
+  /* Pointers in arg to the start, and one past the end, of the
+     condition.  */
+  char **cond_string = (char **) NULL;
+  char *addr_start = arg;
+  char **addr_string;
+  struct cleanup *old_chain;
+  struct cleanup *breakpoint_chain = NULL;
+  int i;
+  int thread = -1;
+  int ignore_count = 0;
+
+  hardwareflag = flag & BP_HARDWAREFLAG;
+  tempflag = flag & BP_TEMPFLAG;
+
+  sals.sals = NULL;
+  sals.nelts = 0;
+  addr_string = NULL;
+  parse_breakpoint_sals (&arg, &sals, &addr_string);
+
+  if (!sals.nelts)
+    return;
+
+  /* Create a chain of things that always need to be cleaned up. */
+  old_chain = make_cleanup (null_cleanup, 0);
+
+  /* Make sure that all storage allocated to SALS gets freed.  */
+  make_cleanup (xfree, sals.sals);
+
+  /* Cleanup the addr_string array but not its contents. */
+  make_cleanup (xfree, addr_string);
+
+  /* Allocate space for all the cond expressions. */
+  cond = xcalloc (sals.nelts, sizeof (struct expression *));
+  make_cleanup (xfree, cond);
+
+  /* Allocate space for all the cond strings. */
+  cond_string = xcalloc (sals.nelts, sizeof (char **));
+  make_cleanup (xfree, cond_string);
+
+  /* ----------------------------- SNIP -----------------------------
+     Anything added to the cleanup chain beyond this point is assumed
+     to be part of a breakpoint.  If the breakpoint create succeeds
+     then the memory is not reclaimed. */
+  breakpoint_chain = make_cleanup (null_cleanup, 0);
+
+  /* Mark the contents of the addr_string for cleanup.  These go on
+     the breakpoint_chain and only occure if the breakpoint create
+     fails. */
+  for (i = 0; i < sals.nelts; i++)
+    {
+      if (addr_string[i] != NULL)
+	make_cleanup (xfree, addr_string[i]);
+    }
+
+  /* Resolve all line numbers to PC's and verify that the addresses
+     are ok for the target.  */
+  breakpoint_sals_to_pc (&sals, addr_start);
+
+  /* Verify that condition can be parsed, before setting any
+     breakpoints.  Allocate a separate condition expression for each
+     breakpoint. */
+  thread = -1;			/* No specific thread yet */
+  for (i = 0; i < sals.nelts; i++)
+    {
+      char *tok = arg;
+      while (tok && *tok)
+	{
+	  char *end_tok;
+	  int toklen;
+	  char *cond_start = NULL;
+	  char *cond_end = NULL;
+	  while (*tok == ' ' || *tok == '\t')
+	    tok++;
+
+	  end_tok = tok;
+
+	  while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
+	    end_tok++;
+
+	  toklen = end_tok - tok;
+
+	  if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
+	    {
+	      tok = cond_start = end_tok + 1;
+	      cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
+	      make_cleanup (xfree, cond[i]);
+	      cond_end = tok;
+	      cond_string[i] = savestring (cond_start, cond_end - cond_start);
+	      make_cleanup (xfree, cond_string[i]);
+	    }
+	  else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
+	    {
+	      char *tmptok;
+
+	      tok = end_tok + 1;
+	      tmptok = tok;
+	      thread = strtol (tok, &tok, 0);
+	      if (tok == tmptok)
+		error ("Junk after thread keyword.");
+	      if (!valid_thread_id (thread))
+		error ("Unknown thread %d\n", thread);
+	    }
+	  else
+	    error ("Junk at end of arguments.");
+	}
+    }
+
+  create_breakpoints (sals, addr_string, cond, cond_string,
+		      hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
+		      tempflag ? disp_del : disp_donttouch,
+		      thread, ignore_count, from_tty);
+
+  if (sals.nelts > 1)
+    {
+      warning ("Multiple breakpoints were set.");
+      warning ("Use the \"delete\" command to delete unwanted breakpoints.");
+    }
+  /* That's it. Discard the cleanups for data inserted into the
+     breakpoint. */
+  discard_cleanups (breakpoint_chain);
+  /* But cleanup everything else. */
+  do_cleanups (old_chain);
+}
+
+/* Set a breakpoint of TYPE/DISPOSITION according to ARG (function,
+   linenum or *address) with COND and IGNORE_COUNT. */
+
+struct captured_breakpoint_args
+  {
+    char *address;
+    char *condition;
+    int hardwareflag;
+    int tempflag;
+    int thread;
+    int ignore_count;
+  };
+
+static int
+do_captured_breakpoint (void *data)
+{
+  struct captured_breakpoint_args *args = data;
+  struct symtabs_and_lines sals;
+  register struct expression **cond;
+  struct cleanup *old_chain;
+  struct cleanup *breakpoint_chain = NULL;
+  int i;
+  char **addr_string;
+  char **cond_string;
+
+  char *address_end;
+
+  /* Parse the source and lines spec.  Delay check that the expression
+     didn't contain trailing garbage until after cleanups are in
+     place. */
+  sals.sals = NULL;
+  sals.nelts = 0;
+  address_end = args->address;
+  addr_string = NULL;
+  parse_breakpoint_sals (&address_end, &sals, &addr_string);
+
+  if (!sals.nelts)
+    return GDB_RC_NONE;
+
+  /* Create a chain of things at always need to be cleaned up. */
+  old_chain = make_cleanup (null_cleanup, 0);
+
+  /* Always have a addr_string array, even if it is empty. */
+  make_cleanup (xfree, addr_string);
+
+  /* Make sure that all storage allocated to SALS gets freed.  */
+  make_cleanup (xfree, sals.sals);
+
+  /* Allocate space for all the cond expressions. */
+  cond = xcalloc (sals.nelts, sizeof (struct expression *));
+  make_cleanup (xfree, cond);
+
+  /* Allocate space for all the cond strings. */
+  cond_string = xcalloc (sals.nelts, sizeof (char **));
+  make_cleanup (xfree, cond_string);
+
+  /* ----------------------------- SNIP -----------------------------
+     Anything added to the cleanup chain beyond this point is assumed
+     to be part of a breakpoint.  If the breakpoint create goes
+     through then that memory is not cleaned up. */
+  breakpoint_chain = make_cleanup (null_cleanup, 0);
+
+  /* Mark the contents of the addr_string for cleanup.  These go on
+     the breakpoint_chain and only occure if the breakpoint create
+     fails. */
+  for (i = 0; i < sals.nelts; i++)
+    {
+      if (addr_string[i] != NULL)
+	make_cleanup (xfree, addr_string[i]);
+    }
+
+  /* Wait until now before checking for garbage at the end of the
+     address. That way cleanups can take care of freeing any
+     memory. */
+  if (*address_end != '\0')
+    error ("Garbage %s following breakpoint address", address_end);
+
+  /* Resolve all line numbers to PC's.  */
+  breakpoint_sals_to_pc (&sals, args->address);
+
+  /* Verify that conditions can be parsed, before setting any
+     breakpoints.  */
+  for (i = 0; i < sals.nelts; i++)
+    {
+      if (args->condition != NULL)
+	{
+	  char *tok = args->condition;
+	  cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
+	  if (*tok != '\0')
+	    error ("Garbage %s follows condition", tok);
+	  make_cleanup (xfree, cond[i]);
+	  cond_string[i] = xstrdup (args->condition);
+	}
+    }
+
+  create_breakpoints (sals, addr_string, cond, cond_string,
+		      args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
+		      args->tempflag ? disp_del : disp_donttouch,
+		      args->thread, args->ignore_count, 0/*from-tty*/);
+
+  /* That's it. Discard the cleanups for data inserted into the
+     breakpoint. */
+  discard_cleanups (breakpoint_chain);
+  /* But cleanup everything else. */
+  do_cleanups (old_chain);
+  return GDB_RC_OK;
+}
+
+enum gdb_rc
+gdb_breakpoint (char *address, char *condition,
+		int hardwareflag, int tempflag,
+		int thread, int ignore_count)
+{
+  struct captured_breakpoint_args args;
+  args.address = address;
+  args.condition = condition;
+  args.hardwareflag = hardwareflag;
+  args.tempflag = tempflag;
+  args.thread = thread;
+  args.ignore_count = ignore_count;
+  return catch_errors (do_captured_breakpoint, &args,
+		       NULL, RETURN_MASK_ALL);
+}
+
+
+static void
+break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty)
+{
+  struct frame_info *frame;
+  CORE_ADDR low, high, selected_pc = 0;
+  char *extra_args = NULL;
+  char *level_arg;
+  char *addr_string;
+  int extra_args_len = 0, if_arg = 0;
+
+  if (!arg ||
+      (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
+    {
+
+      if (default_breakpoint_valid)
+	{
+	  if (selected_frame)
+	    {
+	      selected_pc = selected_frame->pc;
+	      if (arg)
+		if_arg = 1;
+	    }
+	  else
+	    error ("No selected frame.");
+	}
+      else
+	error ("No default breakpoint address now.");
+    }
+  else
+    {
+      extra_args = strchr (arg, ' ');
+      if (extra_args)
+	{
+	  extra_args++;
+	  extra_args_len = strlen (extra_args);
+	  level_arg = (char *) xmalloc (extra_args - arg);
+	  strncpy (level_arg, arg, extra_args - arg - 1);
+	  level_arg[extra_args - arg - 1] = '\0';
+	}
+      else
+	{
+	  level_arg = (char *) xmalloc (strlen (arg) + 1);
+	  strcpy (level_arg, arg);
+	}
+
+      frame = parse_frame_specification (level_arg);
+      if (frame)
+	selected_pc = frame->pc;
+      else
+	selected_pc = 0;
+    }
+  if (if_arg)
+    {
+      extra_args = arg;
+      extra_args_len = strlen (arg);
+    }
+
+  if (selected_pc)
+    {
+      if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high))
+	{
+	  addr_string = (char *) xmalloc (26 + extra_args_len);
+	  if (extra_args_len)
+	    sprintf (addr_string, "*0x%s %s", paddr_nz (high), extra_args);
+	  else
+	    sprintf (addr_string, "*0x%s", paddr_nz (high));
+	  break_command_1 (addr_string, flag, from_tty);
+	  xfree (addr_string);
+	}
+      else
+	error ("No function contains the specified address");
+    }
+  else
+    error ("Unable to set breakpoint at procedure exit");
+}
+
+
+static void
+break_at_finish_command_1 (char *arg, int flag, int from_tty)
+{
+  char *addr_string, *break_string, *beg_addr_string;
+  CORE_ADDR low, high;
+  struct symtabs_and_lines sals;
+  struct symtab_and_line sal;
+  struct cleanup *old_chain;
+  char *extra_args = NULL;
+  int extra_args_len = 0;
+  int i, if_arg = 0;
+
+  if (!arg ||
+      (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t')))
+    {
+      if (default_breakpoint_valid)
+	{
+	  if (selected_frame)
+	    {
+	      addr_string = (char *) xmalloc (15);
+	      sprintf (addr_string, "*0x%s", paddr_nz (selected_frame->pc));
+	      if (arg)
+		if_arg = 1;
+	    }
+	  else
+	    error ("No selected frame.");
+	}
+      else
+	error ("No default breakpoint address now.");
+    }
+  else
+    {
+      addr_string = (char *) xmalloc (strlen (arg) + 1);
+      strcpy (addr_string, arg);
+    }
+
+  if (if_arg)
+    {
+      extra_args = arg;
+      extra_args_len = strlen (arg);
+    }
+  else if (arg)
+    {
+      /* get the stuff after the function name or address */
+      extra_args = strchr (arg, ' ');
+      if (extra_args)
+	{
+	  extra_args++;
+	  extra_args_len = strlen (extra_args);
+	}
+    }
+
+  sals.sals = NULL;
+  sals.nelts = 0;
+
+  beg_addr_string = addr_string;
+  sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
+			(char ***) NULL);
+
+  xfree (beg_addr_string);
+  old_chain = make_cleanup (xfree, sals.sals);
+  for (i = 0; (i < sals.nelts); i++)
+    {
+      sal = sals.sals[i];
+      if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high))
+	{
+	  break_string = (char *) xmalloc (extra_args_len + 26);
+	  if (extra_args_len)
+	    sprintf (break_string, "*0x%s %s", paddr_nz (high), extra_args);
+	  else
+	    sprintf (break_string, "*0x%s", paddr_nz (high));
+	  break_command_1 (break_string, flag, from_tty);
+	  xfree (break_string);
+	}
+      else
+	error ("No function contains the specified address");
+    }
+  if (sals.nelts > 1)
+    {
+      warning ("Multiple breakpoints were set.\n");
+      warning ("Use the \"delete\" command to delete unwanted breakpoints.");
+    }
+  do_cleanups (old_chain);
+}
+
+
+/* Helper function for break_command_1 and disassemble_command.  */
+
+void
+resolve_sal_pc (struct symtab_and_line *sal)
+{
+  CORE_ADDR pc;
+
+  if (sal->pc == 0 && sal->symtab != NULL)
+    {
+      if (!find_line_pc (sal->symtab, sal->line, &pc))
+	error ("No line %d in file \"%s\".",
+	       sal->line, sal->symtab->filename);
+      sal->pc = pc;
+    }
+
+  if (sal->section == 0 && sal->symtab != NULL)
+    {
+      struct blockvector *bv;
+      struct block *b;
+      struct symbol *sym;
+      int index;
+
+      bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab);
+      if (bv != NULL)
+	{
+	  b = BLOCKVECTOR_BLOCK (bv, index);
+	  sym = block_function (b);
+	  if (sym != NULL)
+	    {
+	      fixup_symbol_section (sym, sal->symtab->objfile);
+	      sal->section = SYMBOL_BFD_SECTION (sym);
+	    }
+	  else
+	    {
+	      /* It really is worthwhile to have the section, so we'll just
+	         have to look harder. This case can be executed if we have 
+	         line numbers but no functions (as can happen in assembly 
+	         source).  */
+
+	      struct minimal_symbol *msym;
+
+	      msym = lookup_minimal_symbol_by_pc (sal->pc);
+	      if (msym)
+		sal->section = SYMBOL_BFD_SECTION (msym);
+	    }
+	}
+    }
+}
+
+void
+break_command (char *arg, int from_tty)
+{
+  break_command_1 (arg, 0, from_tty);
+}
+
+void
+break_at_finish_command (char *arg, int from_tty)
+{
+  break_at_finish_command_1 (arg, 0, from_tty);
+}
+
+void
+break_at_finish_at_depth_command (char *arg, int from_tty)
+{
+  break_at_finish_at_depth_command_1 (arg, 0, from_tty);
+}
+
+void
+tbreak_command (char *arg, int from_tty)
+{
+  break_command_1 (arg, BP_TEMPFLAG, from_tty);
+}
+
+void
+tbreak_at_finish_command (char *arg, int from_tty)
+{
+  break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty);
+}
+
+static void
+hbreak_command (char *arg, int from_tty)
+{
+  break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
+}
+
+static void
+thbreak_command (char *arg, int from_tty)
+{
+  break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);
+}
+
+static void
+stop_command (char *arg, int from_tty)
+{
+  printf_filtered ("Specify the type of breakpoint to set.\n\
+Usage: stop in <function | address>\n\
+       stop at <line>\n");
+}
+
+static void
+stopin_command (char *arg, int from_tty)
+{
+  int badInput = 0;
+
+  if (arg == (char *) NULL)
+    badInput = 1;
+  else if (*arg != '*')
+    {
+      char *argptr = arg;
+      int hasColon = 0;
+
+      /* look for a ':'.  If this is a line number specification, then
+         say it is bad, otherwise, it should be an address or
+         function/method name */
+      while (*argptr && !hasColon)
+	{
+	  hasColon = (*argptr == ':');
+	  argptr++;
+	}
+
+      if (hasColon)
+	badInput = (*argptr != ':');	/* Not a class::method */
+      else
+	badInput = isdigit (*arg);	/* a simple line number */
+    }
+
+  if (badInput)
+    printf_filtered ("Usage: stop in <function | address>\n");
+  else
+    break_command_1 (arg, 0, from_tty);
+}
+
+static void
+stopat_command (char *arg, int from_tty)
+{
+  int badInput = 0;
+
+  if (arg == (char *) NULL || *arg == '*')	/* no line number */
+    badInput = 1;
+  else
+    {
+      char *argptr = arg;
+      int hasColon = 0;
+
+      /* look for a ':'.  If there is a '::' then get out, otherwise
+         it is probably a line number. */
+      while (*argptr && !hasColon)
+	{
+	  hasColon = (*argptr == ':');
+	  argptr++;
+	}
+
+      if (hasColon)
+	badInput = (*argptr == ':');	/* we have class::method */
+      else
+	badInput = !isdigit (*arg);	/* not a line number */
+    }
+
+  if (badInput)
+    printf_filtered ("Usage: stop at <line>\n");
+  else
+    break_command_1 (arg, 0, from_tty);
+}
+
+/* ARGSUSED */
+/* accessflag:  hw_write:  watch write, 
+                hw_read:   watch read, 
+		hw_access: watch access (read or write) */
+static void
+watch_command_1 (char *arg, int accessflag, int from_tty)
+{
+  struct breakpoint *b;
+  struct symtab_and_line sal;
+  struct expression *exp;
+  struct block *exp_valid_block;
+  struct value *val, *mark;
+  struct frame_info *frame;
+  struct frame_info *prev_frame = NULL;
+  char *exp_start = NULL;
+  char *exp_end = NULL;
+  char *tok, *end_tok;
+  int toklen;
+  char *cond_start = NULL;
+  char *cond_end = NULL;
+  struct expression *cond = NULL;
+  int i, other_type_used, target_resources_ok = 0;
+  enum bptype bp_type;
+  int mem_cnt = 0;
+
+  INIT_SAL (&sal);		/* initialize to zeroes */
+
+  /* Parse arguments.  */
+  innermost_block = NULL;
+  exp_start = arg;
+  exp = parse_exp_1 (&arg, 0, 0);
+  exp_end = arg;
+  exp_valid_block = innermost_block;
+  mark = value_mark ();
+  val = evaluate_expression (exp);
+  release_value (val);
+  if (VALUE_LAZY (val))
+    value_fetch_lazy (val);
+
+  tok = arg;
+  while (*tok == ' ' || *tok == '\t')
+    tok++;
+  end_tok = tok;
+
+  while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
+    end_tok++;
+
+  toklen = end_tok - tok;
+  if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
+    {
+      tok = cond_start = end_tok + 1;
+      cond = parse_exp_1 (&tok, 0, 0);
+      cond_end = tok;
+    }
+  if (*tok)
+    error ("Junk at end of command.");
+
+  if (accessflag == hw_read)
+    bp_type = bp_read_watchpoint;
+  else if (accessflag == hw_access)
+    bp_type = bp_access_watchpoint;
+  else
+    bp_type = bp_hardware_watchpoint;
+
+  mem_cnt = can_use_hardware_watchpoint (val);
+  if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
+    error ("Expression cannot be implemented with read/access watchpoint.");
+  if (mem_cnt != 0)
+    {
+      i = hw_watchpoint_used_count (bp_type, &other_type_used);
+      target_resources_ok = 
+	TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt, 
+					    other_type_used);
+      if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
+	error ("Target does not support this type of hardware watchpoint.");
+
+      if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
+	error ("Target can only support one kind of HW watchpoint at a time.");
+    }
+
+#if defined(HPUXHPPA)
+  /*  On HP-UX if you set a h/w
+     watchpoint before the "run" command, the inferior dies with a e.g.,
+     SIGILL once you start it.  I initially believed this was due to a
+     bad interaction between page protection traps and the initial
+     startup sequence by the dynamic linker.
+
+     However, I tried avoiding that by having HP-UX's implementation of
+     TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
+     yet, which forced slow watches before a "run" or "attach", and it
+     still fails somewhere in the startup code.
+
+     Until I figure out what's happening, I'm disallowing watches altogether
+     before the "run" or "attach" command.  We'll tell the user they must
+     set watches after getting the program started. */
+  if (!target_has_execution)
+    {
+      warning ("can't do that without a running program; try \"break main\", \"run\" first");
+      return;
+    }
+#endif /* HPUXHPPA */
+
+  /* Change the type of breakpoint to an ordinary watchpoint if a hardware
+     watchpoint could not be set.  */
+  if (!mem_cnt || target_resources_ok <= 0)
+    bp_type = bp_watchpoint;
+
+  /* Now set up the breakpoint.  */
+  b = set_raw_breakpoint (sal, bp_type);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->disposition = disp_donttouch;
+  b->exp = exp;
+  b->exp_valid_block = exp_valid_block;
+  b->exp_string = savestring (exp_start, exp_end - exp_start);
+  b->val = val;
+  b->cond = cond;
+  if (cond_start)
+    b->cond_string = savestring (cond_start, cond_end - cond_start);
+  else
+    b->cond_string = 0;
+
+  frame = block_innermost_frame (exp_valid_block);
+  if (frame)
+    {
+      prev_frame = get_prev_frame (frame);
+      get_frame_id (frame, &b->watchpoint_frame);
+    }
+  else
+    {
+      memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame));
+    }
+
+  /* If the expression is "local", then set up a "watchpoint scope"
+     breakpoint at the point where we've left the scope of the watchpoint
+     expression.  */
+  if (innermost_block)
+    {
+      if (prev_frame)
+	{
+	  struct breakpoint *scope_breakpoint;
+	  scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame),
+							 bp_watchpoint_scope);
+
+	  scope_breakpoint->enable_state = bp_enabled;
+
+	  /* Automatically delete the breakpoint when it hits.  */
+	  scope_breakpoint->disposition = disp_del;
+
+	  /* Only break in the proper frame (help with recursion).  */
+	  scope_breakpoint->frame = prev_frame->frame;
+
+	  /* Set the address at which we will stop.  */
+	  scope_breakpoint->address = get_frame_pc (prev_frame);
+
+	  /* The scope breakpoint is related to the watchpoint.  We
+	     will need to act on them together.  */
+	  b->related_breakpoint = scope_breakpoint;
+	}
+    }
+  value_free_to_mark (mark);
+  mention (b);
+}
+
+/* Return count of locations need to be watched and can be handled
+   in hardware.  If the watchpoint can not be handled
+   in hardware return zero.  */
+
+#if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
+#define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(BYTE_SIZE) \
+    ((BYTE_SIZE) <= (REGISTER_SIZE))
+#endif
+
+#if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
+#define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
+     (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
+#endif
+
+static int
+can_use_hardware_watchpoint (struct value *v)
+{
+  int found_memory_cnt = 0;
+  struct value *head = v;
+
+  /* Did the user specifically forbid us to use hardware watchpoints? */
+  if (!can_use_hw_watchpoints)
+    return 0;
+
+  /* Make sure that the value of the expression depends only upon
+     memory contents, and values computed from them within GDB.  If we
+     find any register references or function calls, we can't use a
+     hardware watchpoint.
+
+     The idea here is that evaluating an expression generates a series
+     of values, one holding the value of every subexpression.  (The
+     expression a*b+c has five subexpressions: a, b, a*b, c, and
+     a*b+c.)  GDB's values hold almost enough information to establish
+     the criteria given above --- they identify memory lvalues,
+     register lvalues, computed values, etcetera.  So we can evaluate
+     the expression, and then scan the chain of values that leaves
+     behind to decide whether we can detect any possible change to the
+     expression's final value using only hardware watchpoints.
+
+     However, I don't think that the values returned by inferior
+     function calls are special in any way.  So this function may not
+     notice that an expression involving an inferior function call
+     can't be watched with hardware watchpoints.  FIXME.  */
+  for (; v; v = v->next)
+    {
+      if (VALUE_LVAL (v) == lval_memory)
+	{
+	  if (VALUE_LAZY (v))
+	    /* A lazy memory lvalue is one that GDB never needed to fetch;
+	       we either just used its address (e.g., `a' in `a.b') or
+	       we never needed it at all (e.g., `a' in `a,b').  */
+	    ;
+	  else
+	    {
+	      /* Ahh, memory we actually used!  Check if we can cover
+                 it with hardware watchpoints.  */
+	      struct type *vtype = check_typedef (VALUE_TYPE (v));
+
+	      /* We only watch structs and arrays if user asked for it
+		 explicitly, never if they just happen to appear in a
+		 middle of some value chain.  */
+	      if (v == head
+		  || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT
+		      && TYPE_CODE (vtype) != TYPE_CODE_ARRAY))
+		{
+		  CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
+		  int       len   = TYPE_LENGTH (VALUE_TYPE (v));
+
+		  if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len))
+		    return 0;
+		  else
+		    found_memory_cnt++;
+		}
+	    }
+	}
+      else if (v->lval != not_lval && v->modifiable == 0)
+	return 0;	/* ??? What does this represent? */
+      else if (v->lval == lval_register)
+	return 0;	/* cannot watch a register with a HW watchpoint */
+    }
+
+  /* The expression itself looks suitable for using a hardware
+     watchpoint, but give the target machine a chance to reject it.  */
+  return found_memory_cnt;
+}
+
+void
+watch_command_wrapper (char *arg, int from_tty)
+{
+  watch_command (arg, from_tty);
+}
+
+static void
+watch_command (char *arg, int from_tty)
+{
+  watch_command_1 (arg, hw_write, from_tty);
+}
+
+void
+rwatch_command_wrapper (char *arg, int from_tty)
+{
+  rwatch_command (arg, from_tty);
+}
+
+static void
+rwatch_command (char *arg, int from_tty)
+{
+  watch_command_1 (arg, hw_read, from_tty);
+}
+
+void
+awatch_command_wrapper (char *arg, int from_tty)
+{
+  awatch_command (arg, from_tty);
+}
+
+static void
+awatch_command (char *arg, int from_tty)
+{
+  watch_command_1 (arg, hw_access, from_tty);
+}
+
+
+/* Helper routines for the until_command routine in infcmd.c.  Here
+   because it uses the mechanisms of breakpoints.  */
+
+/* This function is called by fetch_inferior_event via the
+   cmd_continuation pointer, to complete the until command. It takes
+   care of cleaning up the temporary breakpoints set up by the until
+   command. */
+static void
+until_break_command_continuation (struct continuation_arg *arg)
+{
+  struct cleanup *cleanups;
+
+  cleanups = (struct cleanup *) arg->data.pointer;
+  do_exec_cleanups (cleanups);
+}
+
+/* ARGSUSED */
+void
+until_break_command (char *arg, int from_tty)
+{
+  struct symtabs_and_lines sals;
+  struct symtab_and_line sal;
+  struct frame_info *prev_frame = get_prev_frame (selected_frame);
+  struct breakpoint *breakpoint;
+  struct cleanup *old_chain;
+  struct continuation_arg *arg1;
+
+
+  clear_proceed_status ();
+
+  /* Set a breakpoint where the user wants it and at return from
+     this function */
+
+  if (default_breakpoint_valid)
+    sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
+			  default_breakpoint_line, (char ***) NULL);
+  else
+    sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 
+			  0, (char ***) NULL);
+
+  if (sals.nelts != 1)
+    error ("Couldn't get information on specified line.");
+
+  sal = sals.sals[0];
+  xfree (sals.sals);	/* malloc'd, so freed */
+
+  if (*arg)
+    error ("Junk at end of arguments.");
+
+  resolve_sal_pc (&sal);
+
+  breakpoint = set_momentary_breakpoint (sal, selected_frame, bp_until);
+
+  if (!event_loop_p || !target_can_async_p ())
+    old_chain = make_cleanup_delete_breakpoint (breakpoint);
+  else
+    old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
+
+  /* If we are running asynchronously, and the target supports async
+     execution, we are not waiting for the target to stop, in the call
+     tp proceed, below. This means that we cannot delete the
+     brekpoints until the target has actually stopped. The only place
+     where we get a chance to do that is in fetch_inferior_event, so
+     we must set things up for that. */
+
+  if (event_loop_p && target_can_async_p ())
+    {
+      /* In this case the arg for the continuation is just the point
+         in the exec_cleanups chain from where to start doing
+         cleanups, because all the continuation does is the cleanups in
+         the exec_cleanup_chain. */
+      arg1 =
+	(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
+      arg1->next         = NULL;
+      arg1->data.pointer = old_chain;
+
+      add_continuation (until_break_command_continuation, arg1);
+    }
+
+  /* Keep within the current frame */
+
+  if (prev_frame)
+    {
+      sal = find_pc_line (prev_frame->pc, 0);
+      sal.pc = prev_frame->pc;
+      breakpoint = set_momentary_breakpoint (sal, prev_frame, bp_until);
+      if (!event_loop_p || !target_can_async_p ())
+	make_cleanup_delete_breakpoint (breakpoint);
+      else
+	make_exec_cleanup_delete_breakpoint (breakpoint);
+    }
+
+  proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
+  /* Do the cleanups now, anly if we are not running asynchronously,
+     of if we are, but the target is still synchronous. */
+  if (!event_loop_p || !target_can_async_p ())
+    do_cleanups (old_chain);
+}
+
+#if 0
+/* These aren't used; I don't konw what they were for.  */
+/* Set a breakpoint at the catch clause for NAME.  */
+static int
+catch_breakpoint (char *name)
+{
+}
+
+static int
+disable_catch_breakpoint (void)
+{
+}
+
+static int
+delete_catch_breakpoint (void)
+{
+}
+
+static int
+enable_catch_breakpoint (void)
+{
+}
+#endif /* 0 */
+
+struct sal_chain
+{
+  struct sal_chain *next;
+  struct symtab_and_line sal;
+};
+
+#if 0
+/* Not really used -- invocation in handle_gnu_4_16_catch_command
+   had been commented out in the v.4.16 sources, and stays
+   disabled there now because "catch NAME" syntax isn't allowed.
+   pai/1997-07-11 */
+/* This isn't used; I don't know what it was for.  */
+/* For each catch clause identified in ARGS, run FUNCTION
+   with that clause as an argument.  */
+static struct symtabs_and_lines
+map_catch_names (char *args, int (*function) ())
+{
+  register char *p = args;
+  register char *p1;
+  struct symtabs_and_lines sals;
+#if 0
+  struct sal_chain *sal_chain = 0;
+#endif
+
+  if (p == 0)
+    error_no_arg ("one or more catch names");
+
+  sals.nelts = 0;
+  sals.sals = NULL;
+
+  while (*p)
+    {
+      p1 = p;
+      /* Don't swallow conditional part.  */
+      if (p1[0] == 'i' && p1[1] == 'f'
+	  && (p1[2] == ' ' || p1[2] == '\t'))
+	break;
+
+      if (isalpha (*p1))
+	{
+	  p1++;
+	  while (isalnum (*p1) || *p1 == '_' || *p1 == '$')
+	    p1++;
+	}
+
+      if (*p1 && *p1 != ' ' && *p1 != '\t')
+	error ("Arguments must be catch names.");
+
+      *p1 = 0;
+#if 0
+      if (function (p))
+	{
+	  struct sal_chain *next = (struct sal_chain *)
+	  alloca (sizeof (struct sal_chain));
+	  next->next = sal_chain;
+	  next->sal = get_catch_sal (p);
+	  sal_chain = next;
+	  goto win;
+	}
+#endif
+      printf_unfiltered ("No catch clause for exception %s.\n", p);
+#if 0
+    win:
+#endif
+      p = p1;
+      while (*p == ' ' || *p == '\t')
+	p++;
+    }
+}
+#endif
+
+/* This shares a lot of code with `print_frame_label_vars' from stack.c.  */
+
+static struct symtabs_and_lines
+get_catch_sals (int this_level_only)
+{
+  register struct blockvector *bl;
+  register struct block *block;
+  int index, have_default = 0;
+  CORE_ADDR pc;
+  struct symtabs_and_lines sals;
+  struct sal_chain *sal_chain = 0;
+  char *blocks_searched;
+
+  /* Not sure whether an error message is always the correct response,
+     but it's better than a core dump.  */
+  if (selected_frame == NULL)
+    error ("No selected frame.");
+  block = get_frame_block (selected_frame, 0);
+  pc = selected_frame->pc;
+
+  sals.nelts = 0;
+  sals.sals = NULL;
+
+  if (block == 0)
+    error ("No symbol table info available.\n");
+
+  bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
+  blocks_searched = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
+  memset (blocks_searched, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
+
+  while (block != 0)
+    {
+      CORE_ADDR end = BLOCK_END (block) - 4;
+      int last_index;
+
+      if (bl != blockvector_for_pc (end, &index))
+	error ("blockvector blotch");
+      if (BLOCKVECTOR_BLOCK (bl, index) != block)
+	error ("blockvector botch");
+      last_index = BLOCKVECTOR_NBLOCKS (bl);
+      index += 1;
+
+      /* Don't print out blocks that have gone by.  */
+      while (index < last_index
+	     && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
+	index++;
+
+      while (index < last_index
+	     && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
+	{
+	  if (blocks_searched[index] == 0)
+	    {
+	      struct block *b = BLOCKVECTOR_BLOCK (bl, index);
+	      register int i;
+	      register struct symbol *sym;
+
+	      ALL_BLOCK_SYMBOLS (b, i, sym)
+		{
+		  if (STREQ (SYMBOL_NAME (sym), "default"))
+		    {
+		      if (have_default)
+			continue;
+		      have_default = 1;
+		    }
+		  if (SYMBOL_CLASS (sym) == LOC_LABEL)
+		    {
+		      struct sal_chain *next = (struct sal_chain *)
+		      alloca (sizeof (struct sal_chain));
+		      next->next = sal_chain;
+		      next->sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 
+						0);
+		      sal_chain = next;
+		    }
+		}
+	      blocks_searched[index] = 1;
+	    }
+	  index++;
+	}
+      if (have_default)
+	break;
+      if (sal_chain && this_level_only)
+	break;
+
+      /* After handling the function's top-level block, stop.
+         Don't continue to its superblock, the block of
+         per-file symbols.  */
+      if (BLOCK_FUNCTION (block))
+	break;
+      block = BLOCK_SUPERBLOCK (block);
+    }
+
+  if (sal_chain)
+    {
+      struct sal_chain *tmp_chain;
+
+      /* Count the number of entries.  */
+      for (index = 0, tmp_chain = sal_chain; tmp_chain;
+	   tmp_chain = tmp_chain->next)
+	index++;
+
+      sals.nelts = index;
+      sals.sals = (struct symtab_and_line *)
+	xmalloc (index * sizeof (struct symtab_and_line));
+      for (index = 0; sal_chain; sal_chain = sal_chain->next, index++)
+	sals.sals[index] = sal_chain->sal;
+    }
+
+  return sals;
+}
+
+static void
+ep_skip_leading_whitespace (char **s)
+{
+  if ((s == NULL) || (*s == NULL))
+    return;
+  while (isspace (**s))
+    *s += 1;
+}
+
+/* This function examines a string, and attempts to find a token
+   that might be an event name in the leading characters.  If a
+   possible match is found, a pointer to the last character of
+   the token is returned.  Else, NULL is returned. */
+
+static char *
+ep_find_event_name_end (char *arg)
+{
+  char *s = arg;
+  char *event_name_end = NULL;
+
+  /* If we could depend upon the presense of strrpbrk, we'd use that... */
+  if (arg == NULL)
+    return NULL;
+
+  /* We break out of the loop when we find a token delimiter.
+     Basically, we're looking for alphanumerics and underscores;
+     anything else delimites the token. */
+  while (*s != '\0')
+    {
+      if (!isalnum (*s) && (*s != '_'))
+	break;
+      event_name_end = s;
+      s++;
+    }
+
+  return event_name_end;
+}
+
+
+/* This function attempts to parse an optional "if <cond>" clause
+   from the arg string.  If one is not found, it returns NULL.
+
+   Else, it returns a pointer to the condition string.  (It does not
+   attempt to evaluate the string against a particular block.)  And,
+   it updates arg to point to the first character following the parsed
+   if clause in the arg string. */
+
+static char *
+ep_parse_optional_if_clause (char **arg)
+{
+  char *cond_string;
+
+  if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2]))
+    return NULL;
+
+  /* Skip the "if" keyword. */
+  (*arg) += 2;
+
+  /* Skip any extra leading whitespace, and record the start of the
+     condition string. */
+  ep_skip_leading_whitespace (arg);
+  cond_string = *arg;
+
+  /* Assume that the condition occupies the remainder of the arg string. */
+  (*arg) += strlen (cond_string);
+
+  return cond_string;
+}
+
+/* This function attempts to parse an optional filename from the arg
+   string.  If one is not found, it returns NULL.
+
+   Else, it returns a pointer to the parsed filename.  (This function
+   makes no attempt to verify that a file of that name exists, or is
+   accessible.)  And, it updates arg to point to the first character
+   following the parsed filename in the arg string.
+
+   Note that clients needing to preserve the returned filename for
+   future access should copy it to their own buffers. */
+static char *
+ep_parse_optional_filename (char **arg)
+{
+  static char filename[1024];
+  char *arg_p = *arg;
+  int i;
+  char c;
+
+  if ((*arg_p == '\0') || isspace (*arg_p))
+    return NULL;
+
+  for (i = 0;; i++)
+    {
+      c = *arg_p;
+      if (isspace (c))
+	c = '\0';
+      filename[i] = c;
+      if (c == '\0')
+	break;
+      arg_p++;
+    }
+  *arg = arg_p;
+
+  return filename;
+}
+
+/* Commands to deal with catching events, such as signals, exceptions,
+   process start/exit, etc.  */
+
+typedef enum
+{
+  catch_fork, catch_vfork
+}
+catch_fork_kind;
+
+#if defined(CHILD_INSERT_FORK_CATCHPOINT) || defined(CHILD_INSERT_VFORK_CATCHPOINT)
+static void catch_fork_command_1 (catch_fork_kind fork_kind,
+				  char *arg, int tempflag, int from_tty);
+
+static void
+catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag,
+		      int from_tty)
+{
+  char *cond_string = NULL;
+
+  ep_skip_leading_whitespace (&arg);
+
+  /* The allowed syntax is:
+     catch [v]fork
+     catch [v]fork if <cond>
+
+     First, check if there's an if clause. */
+  cond_string = ep_parse_optional_if_clause (&arg);
+
+  if ((*arg != '\0') && !isspace (*arg))
+    error ("Junk at end of arguments.");
+
+  /* If this target supports it, create a fork or vfork catchpoint
+     and enable reporting of such events. */
+  switch (fork_kind)
+    {
+    case catch_fork:
+      create_fork_event_catchpoint (tempflag, cond_string);
+      break;
+    case catch_vfork:
+      create_vfork_event_catchpoint (tempflag, cond_string);
+      break;
+    default:
+      error ("unsupported or unknown fork kind; cannot catch it");
+      break;
+    }
+}
+#endif
+
+#if defined(CHILD_INSERT_EXEC_CATCHPOINT)
+static void
+catch_exec_command_1 (char *arg, int tempflag, int from_tty)
+{
+  char *cond_string = NULL;
+
+  ep_skip_leading_whitespace (&arg);
+
+  /* The allowed syntax is:
+     catch exec
+     catch exec if <cond>
+
+     First, check if there's an if clause. */
+  cond_string = ep_parse_optional_if_clause (&arg);
+
+  if ((*arg != '\0') && !isspace (*arg))
+    error ("Junk at end of arguments.");
+
+  /* If this target supports it, create an exec catchpoint
+     and enable reporting of such events. */
+  create_exec_event_catchpoint (tempflag, cond_string);
+}
+#endif
+
+#if defined(SOLIB_ADD)
+static void
+catch_load_command_1 (char *arg, int tempflag, int from_tty)
+{
+  char *dll_pathname = NULL;
+  char *cond_string = NULL;
+
+  ep_skip_leading_whitespace (&arg);
+
+  /* The allowed syntax is:
+     catch load
+     catch load if <cond>
+     catch load <filename>
+     catch load <filename> if <cond>
+
+     The user is not allowed to specify the <filename> after an
+     if clause.
+
+     We'll ignore the pathological case of a file named "if".
+
+     First, check if there's an if clause.  If so, then there
+     cannot be a filename. */
+  cond_string = ep_parse_optional_if_clause (&arg);
+
+  /* If there was an if clause, then there cannot be a filename.
+     Else, there might be a filename and an if clause. */
+  if (cond_string == NULL)
+    {
+      dll_pathname = ep_parse_optional_filename (&arg);
+      ep_skip_leading_whitespace (&arg);
+      cond_string = ep_parse_optional_if_clause (&arg);
+    }
+
+  if ((*arg != '\0') && !isspace (*arg))
+    error ("Junk at end of arguments.");
+
+  /* Create a load breakpoint that only triggers when a load of
+     the specified dll (or any dll, if no pathname was specified)
+     occurs. */
+  SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag, 
+				dll_pathname, cond_string);
+}
+
+static void
+catch_unload_command_1 (char *arg, int tempflag, int from_tty)
+{
+  char *dll_pathname = NULL;
+  char *cond_string = NULL;
+
+  ep_skip_leading_whitespace (&arg);
+
+  /* The allowed syntax is:
+     catch unload
+     catch unload if <cond>
+     catch unload <filename>
+     catch unload <filename> if <cond>
+
+     The user is not allowed to specify the <filename> after an
+     if clause.
+
+     We'll ignore the pathological case of a file named "if".
+
+     First, check if there's an if clause.  If so, then there
+     cannot be a filename. */
+  cond_string = ep_parse_optional_if_clause (&arg);
+
+  /* If there was an if clause, then there cannot be a filename.
+     Else, there might be a filename and an if clause. */
+  if (cond_string == NULL)
+    {
+      dll_pathname = ep_parse_optional_filename (&arg);
+      ep_skip_leading_whitespace (&arg);
+      cond_string = ep_parse_optional_if_clause (&arg);
+    }
+
+  if ((*arg != '\0') && !isspace (*arg))
+    error ("Junk at end of arguments.");
+
+  /* Create an unload breakpoint that only triggers when an unload of
+     the specified dll (or any dll, if no pathname was specified)
+     occurs. */
+  SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag, 
+				  dll_pathname, cond_string);
+}
+#endif /* SOLIB_ADD */
+
+/* Commands to deal with catching exceptions.  */
+
+/* Set a breakpoint at the specified callback routine for an
+   exception event callback */
+
+static void
+create_exception_catchpoint (int tempflag, char *cond_string,
+			     enum exception_event_kind ex_event,
+			     struct symtab_and_line *sal)
+{
+  struct breakpoint *b;
+  int thread = -1;		/* All threads. */
+  enum bptype bptype;
+
+  if (!sal)			/* no exception support? */
+    return;
+
+  switch (ex_event)
+    {
+    case EX_EVENT_THROW:
+      bptype = bp_catch_throw;
+      break;
+    case EX_EVENT_CATCH:
+      bptype = bp_catch_catch;
+      break;
+    default:			/* error condition */
+      error ("Internal error -- invalid catchpoint kind");
+    }
+
+  b = set_raw_breakpoint (*sal, bptype);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->cond = NULL;
+  b->cond_string = (cond_string == NULL) ? 
+    NULL : savestring (cond_string, strlen (cond_string));
+  b->thread = thread;
+  b->addr_string = NULL;
+  b->enable_state = bp_enabled;
+  b->disposition = tempflag ? disp_del : disp_donttouch;
+  mention (b);
+}
+
+/* Deal with "catch catch" and "catch throw" commands */
+
+static void
+catch_exception_command_1 (enum exception_event_kind ex_event, char *arg,
+			   int tempflag, int from_tty)
+{
+  char *cond_string = NULL;
+  struct symtab_and_line *sal = NULL;
+
+  ep_skip_leading_whitespace (&arg);
+
+  cond_string = ep_parse_optional_if_clause (&arg);
+
+  if ((*arg != '\0') && !isspace (*arg))
+    error ("Junk at end of arguments.");
+
+  if ((ex_event != EX_EVENT_THROW) &&
+      (ex_event != EX_EVENT_CATCH))
+    error ("Unsupported or unknown exception event; cannot catch it");
+
+  /* See if we can find a callback routine */
+  sal = target_enable_exception_callback (ex_event, 1);
+
+  if (sal)
+    {
+      /* We have callbacks from the runtime system for exceptions.
+         Set a breakpoint on the sal found, if no errors */
+      if (sal != (struct symtab_and_line *) -1)
+	create_exception_catchpoint (tempflag, cond_string, ex_event, sal);
+      else
+	return;		/* something went wrong with setting up callbacks */
+    }
+  else
+    {
+      /* No callbacks from runtime system for exceptions.
+         Try GNU C++ exception breakpoints using labels in debug info. */
+      if (ex_event == EX_EVENT_CATCH)
+	{
+	  handle_gnu_4_16_catch_command (arg, tempflag, from_tty);
+	}
+      else if (ex_event == EX_EVENT_THROW)
+	{
+	  /* Set a breakpoint on __raise_exception () */
+
+	  warning ("Unsupported with this platform/compiler combination.");
+	  warning ("Perhaps you can achieve the effect you want by setting");
+	  warning ("a breakpoint on __raise_exception().");
+	}
+    }
+}
+
+/* Cover routine to allow wrapping target_enable_exception_catchpoints
+   inside a catch_errors */
+
+static int
+cover_target_enable_exception_callback (PTR arg)
+{
+  args_for_catchpoint_enable *args = arg;
+  struct symtab_and_line *sal;
+  sal = target_enable_exception_callback (args->kind, args->enable_p);
+  if (sal == NULL)
+    return 0;
+  else if (sal == (struct symtab_and_line *) -1)
+    return -1;
+  else
+    return 1;			/*is valid */
+}
+
+
+
+/* This is the original v.4.16 and earlier version of the
+   catch_command_1() function.  Now that other flavours of "catch"
+   have been introduced, and since exception handling can be handled
+   in other ways (through target ops) also, this is used only for the
+   GNU C++ exception handling system.
+   Note: Only the "catch" flavour of GDB 4.16 is handled here.  The
+   "catch NAME" is now no longer allowed in catch_command_1().  Also,
+   there was no code in GDB 4.16 for "catch throw". 
+
+   Called from catch_exception_command_1 () */
+
+
+static void
+handle_gnu_4_16_catch_command (char *arg, int tempflag, int from_tty)
+{
+  /* First, translate ARG into something we can deal with in terms
+     of breakpoints.  */
+
+  struct symtabs_and_lines sals;
+  struct symtab_and_line sal;
+  register struct expression *cond = 0;
+  register struct breakpoint *b;
+  char *save_arg;
+  int i;
+
+  INIT_SAL (&sal);		/* initialize to zeroes */
+
+  /* If no arg given, or if first arg is 'if ', all active catch clauses
+     are breakpointed. */
+
+  if (!arg || (arg[0] == 'i' && arg[1] == 'f'
+	       && (arg[2] == ' ' || arg[2] == '\t')))
+    {
+      /* Grab all active catch clauses.  */
+      sals = get_catch_sals (0);
+    }
+  else
+    {
+      /* Grab selected catch clauses.  */
+      error ("catch NAME not implemented");
+
+#if 0
+      /* Not sure why this code has been disabled. I'm leaving
+         it disabled.  We can never come here now anyway
+         since we don't allow the "catch NAME" syntax.
+         pai/1997-07-11 */
+
+      /* This isn't used; I don't know what it was for.  */
+      sals = map_catch_names (arg, catch_breakpoint);
+#endif
+    }
+
+  if (!sals.nelts)
+    return;
+
+  save_arg = arg;
+  for (i = 0; i < sals.nelts; i++)
+    {
+      resolve_sal_pc (&sals.sals[i]);
+
+      while (arg && *arg)
+	{
+	  if (arg[0] == 'i' && arg[1] == 'f'
+	      && (arg[2] == ' ' || arg[2] == '\t'))
+	    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;
+    }
+
+  for (i = 0; i < sals.nelts; i++)
+    {
+      sal = sals.sals[i];
+
+      if (from_tty)
+	describe_other_breakpoints (sal.pc, sal.section);
+
+      /* Important -- this is an ordinary breakpoint.  For platforms
+	 with callback support for exceptions,
+	 create_exception_catchpoint() will create special bp types
+	 (bp_catch_catch and bp_catch_throw), and there is code in
+	 insert_breakpoints() and elsewhere that depends on that. */
+      b = set_raw_breakpoint (sal, bp_breakpoint);
+      set_breakpoint_count (breakpoint_count + 1);
+      b->number = breakpoint_count;
+
+      b->cond = cond;
+      b->enable_state = bp_enabled;
+      b->disposition = tempflag ? disp_del : disp_donttouch;
+
+      mention (b);
+    }
+
+  if (sals.nelts > 1)
+    {
+      warning ("Multiple breakpoints were set.");
+      warning ("Use the \"delete\" command to delete unwanted breakpoints.");
+    }
+  xfree (sals.sals);
+}
+
+static void
+catch_command_1 (char *arg, int tempflag, int from_tty)
+{
+
+  /* The first argument may be an event name, such as "start" or "load".
+     If so, then handle it as such.  If it doesn't match an event name,
+     then attempt to interpret it as an exception name.  (This latter is
+     the v4.16-and-earlier GDB meaning of the "catch" command.)
+
+     First, try to find the bounds of what might be an event name. */
+  char *arg1_start = arg;
+  char *arg1_end;
+  int arg1_length;
+
+  if (arg1_start == NULL)
+    {
+      /* Old behaviour was to use pre-v-4.16 syntax */
+      /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
+      /* return; */
+      /* Now, this is not allowed */
+      error ("Catch requires an event name.");
+
+    }
+  arg1_end = ep_find_event_name_end (arg1_start);
+  if (arg1_end == NULL)
+    error ("catch requires an event");
+  arg1_length = arg1_end + 1 - arg1_start;
+
+  /* Try to match what we found against known event names. */
+  if (strncmp (arg1_start, "signal", arg1_length) == 0)
+    {
+      error ("Catch of signal not yet implemented");
+    }
+  else if (strncmp (arg1_start, "catch", arg1_length) == 0)
+    {
+      catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1, 
+				 tempflag, from_tty);
+    }
+  else if (strncmp (arg1_start, "throw", arg1_length) == 0)
+    {
+      catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1, 
+				 tempflag, from_tty);
+    }
+  else if (strncmp (arg1_start, "thread_start", arg1_length) == 0)
+    {
+      error ("Catch of thread_start not yet implemented");
+    }
+  else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0)
+    {
+      error ("Catch of thread_exit not yet implemented");
+    }
+  else if (strncmp (arg1_start, "thread_join", arg1_length) == 0)
+    {
+      error ("Catch of thread_join not yet implemented");
+    }
+  else if (strncmp (arg1_start, "start", arg1_length) == 0)
+    {
+      error ("Catch of start not yet implemented");
+    }
+  else if (strncmp (arg1_start, "exit", arg1_length) == 0)
+    {
+      error ("Catch of exit not yet implemented");
+    }
+  else if (strncmp (arg1_start, "fork", arg1_length) == 0)
+    {
+#if defined(CHILD_INSERT_FORK_CATCHPOINT)
+      catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty);
+#else
+      error ("Catch of fork not yet implemented");
+#endif
+    }
+  else if (strncmp (arg1_start, "vfork", arg1_length) == 0)
+    {
+#if defined(CHILD_INSERT_VFORK_CATCHPOINT)
+      catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty);
+#else
+      error ("Catch of vfork not yet implemented");
+#endif
+    }
+  else if (strncmp (arg1_start, "exec", arg1_length) == 0)
+    {
+#if defined(CHILD_INSERT_EXEC_CATCHPOINT)
+      catch_exec_command_1 (arg1_end + 1, tempflag, from_tty);
+#else
+      error ("Catch of exec not yet implemented");
+#endif
+    }
+  else if (strncmp (arg1_start, "load", arg1_length) == 0)
+    {
+#if defined(SOLIB_ADD)
+      catch_load_command_1 (arg1_end + 1, tempflag, from_tty);
+#else
+      error ("Catch of load not implemented");
+#endif
+    }
+  else if (strncmp (arg1_start, "unload", arg1_length) == 0)
+    {
+#if defined(SOLIB_ADD)
+      catch_unload_command_1 (arg1_end + 1, tempflag, from_tty);
+#else
+      error ("Catch of load not implemented");
+#endif
+    }
+  else if (strncmp (arg1_start, "stop", arg1_length) == 0)
+    {
+      error ("Catch of stop not yet implemented");
+    }
+
+  /* This doesn't appear to be an event name */
+
+  else
+    {
+      /* Pre-v.4.16 behaviour was to treat the argument
+         as the name of an exception */
+      /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */
+      /* Now this is not allowed */
+      error ("Unknown event kind specified for catch");
+
+    }
+}
+
+/* Used by the gui, could be made a worker for other things. */
+
+struct breakpoint *
+set_breakpoint_sal (struct symtab_and_line sal)
+{
+  struct breakpoint *b;
+  b = set_raw_breakpoint (sal, bp_breakpoint);
+  set_breakpoint_count (breakpoint_count + 1);
+  b->number = breakpoint_count;
+  b->cond = 0;
+  b->thread = -1;
+  return b;
+}
+
+#if 0
+/* These aren't used; I don't know what they were for.  */
+/* Disable breakpoints on all catch clauses described in ARGS.  */
+static void
+disable_catch (char *args)
+{
+  /* Map the disable command to catch clauses described in ARGS.  */
+}
+
+/* Enable breakpoints on all catch clauses described in ARGS.  */
+static void
+enable_catch (char *args)
+{
+  /* Map the disable command to catch clauses described in ARGS.  */
+}
+
+/* Delete breakpoints on all catch clauses in the active scope.  */
+static void
+delete_catch (char *args)
+{
+  /* Map the delete command to catch clauses described in ARGS.  */
+}
+#endif /* 0 */
+
+static void
+catch_command (char *arg, int from_tty)
+{
+  catch_command_1 (arg, 0, from_tty);
+}
+
+
+static void
+tcatch_command (char *arg, int from_tty)
+{
+  catch_command_1 (arg, 1, from_tty);
+}
+
+/* Delete breakpoints by address or line.  */
+
+static void
+clear_command (char *arg, int from_tty)
+{
+  struct breakpoint *b, *tmp, *prev, *found;
+  int default_match;
+  struct symtabs_and_lines sals;
+  struct symtab_and_line sal;
+  int i;
+
+  if (arg)
+    {
+      sals = decode_line_spec (arg, 1);
+      default_match = 0;
+    }
+  else
+    {
+      sals.sals = (struct symtab_and_line *)
+	xmalloc (sizeof (struct symtab_and_line));
+      make_cleanup (xfree, sals.sals);
+      INIT_SAL (&sal);		/* initialize to zeroes */
+      sal.line = default_breakpoint_line;
+      sal.symtab = default_breakpoint_symtab;
+      sal.pc = default_breakpoint_address;
+      if (sal.symtab == 0)
+	error ("No source file specified.");
+
+      sals.sals[0] = sal;
+      sals.nelts = 1;
+
+      default_match = 1;
+    }
+
+  /* For each line spec given, delete bps which correspond
+     to it.  Do it in two passes, solely to preserve the current
+     behavior that from_tty is forced true if we delete more than
+     one breakpoint.  */
+
+  found = NULL;
+  for (i = 0; i < sals.nelts; i++)
+    {
+      /* If exact pc given, clear bpts at that pc.
+         If line given (pc == 0), clear all bpts on specified line.
+         If defaulting, clear all bpts on default line
+         or at default pc.
+
+         defaulting    sal.pc != 0    tests to do
+
+         0              1             pc
+         1              1             pc _and_ line
+         0              0             line
+         1              0             <can't happen> */
+
+      sal = sals.sals[i];
+      prev = NULL;
+
+      /* Find all matching breakpoints, remove them from the
+	 breakpoint chain, and add them to the 'found' chain.  */
+      ALL_BREAKPOINTS_SAFE (b, tmp)
+	{
+	  /* Are we going to delete b? */
+	  if (b->type != bp_none
+	      && b->type != bp_watchpoint
+	      && b->type != bp_hardware_watchpoint
+	      && b->type != bp_read_watchpoint
+	      && b->type != bp_access_watchpoint
+	      /* Not if b is a watchpoint of any sort... */
+	      && (((sal.pc && (b->address == sal.pc)) 
+		   && (!section_is_overlay (b->section)
+		       || b->section == sal.section))
+		  /* Yes, if sal.pc matches b (modulo overlays).  */
+		  || ((default_match || (0 == sal.pc))
+		      && b->source_file != NULL
+		      && sal.symtab != NULL
+		      && STREQ (b->source_file, sal.symtab->filename)
+		      && b->line_number == sal.line)))
+	    /* Yes, if sal source file and line matches b.  */
+	    {
+	      /* Remove it from breakpoint_chain...  */
+	      if (b == breakpoint_chain)
+		{
+		  /* b is at the head of the list */
+		  breakpoint_chain = b->next;
+		}
+	      else
+		{
+		  prev->next = b->next;
+		}
+	      /* And add it to 'found' chain.  */
+	      b->next = found;
+	      found = b;
+	    }
+	  else
+	    {
+	      /* Keep b, and keep a pointer to it.  */
+	      prev = b;
+	    }
+	}
+    }
+  /* Now go thru the 'found' chain and delete them.  */
+  if (found == 0)
+    {
+      if (arg)
+	error ("No breakpoint at %s.", arg);
+      else
+	error ("No breakpoint at this line.");
+    }
+
+  if (found->next)
+    from_tty = 1;		/* Always report if deleted more than one */
+  if (from_tty)
+    printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
+  breakpoints_changed ();
+  while (found)
+    {
+      if (from_tty)
+	printf_unfiltered ("%d ", found->number);
+      tmp = found->next;
+      delete_breakpoint (found);
+      found = tmp;
+    }
+  if (from_tty)
+    putchar_unfiltered ('\n');
+}
+
+/* Delete breakpoint in BS if they are `delete' breakpoints and
+   all breakpoints that are marked for deletion, whether hit or not.
+   This is called after any breakpoint is hit, or after errors.  */
+
+void
+breakpoint_auto_delete (bpstat bs)
+{
+  struct breakpoint *b, *temp;
+
+  for (; bs; bs = bs->next)
+    if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
+	&& bs->stop)
+      delete_breakpoint (bs->breakpoint_at);
+
+  ALL_BREAKPOINTS_SAFE (b, temp)
+  {
+    if (b->disposition == disp_del_at_next_stop)
+      delete_breakpoint (b);
+  }
+}
+
+/* Delete a breakpoint and clean up all traces of it in the data
+   structures. */
+
+void
+delete_breakpoint (struct breakpoint *bpt)
+{
+  register struct breakpoint *b;
+  register bpstat bs;
+
+  if (bpt == NULL)
+    error ("Internal error (attempted to delete a NULL breakpoint)");
+
+
+  /* Has this bp already been deleted?  This can happen because multiple
+     lists can hold pointers to bp's.  bpstat lists are especial culprits.
+
+     One example of this happening is a watchpoint's scope bp.  When the
+     scope bp triggers, we notice that the watchpoint is out of scope, and
+     delete it.  We also delete its scope bp.  But the scope bp is marked
+     "auto-deleting", and is already on a bpstat.  That bpstat is then
+     checked for auto-deleting bp's, which are deleted.
+
+     A real solution to this problem might involve reference counts in bp's,
+     and/or giving them pointers back to their referencing bpstat's, and
+     teaching delete_breakpoint to only free a bp's storage when no more
+     references were extent.  A cheaper bandaid was chosen. */
+  if (bpt->type == bp_none)
+    return;
+
+  if (delete_breakpoint_hook)
+    delete_breakpoint_hook (bpt);
+  breakpoint_delete_event (bpt->number);
+
+  if (bpt->inserted)
+    remove_breakpoint (bpt, mark_inserted);
+
+  if (breakpoint_chain == bpt)
+    breakpoint_chain = bpt->next;
+
+  /* If we have callback-style exception catchpoints, don't go through
+     the adjustments to the C++ runtime library etc. if the inferior
+     isn't actually running.  target_enable_exception_callback for a
+     null target ops vector gives an undesirable error message, so we
+     check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's
+     exceptions are supported in this way, it's OK for now. FIXME */
+  if (ep_is_exception_catchpoint (bpt) && target_has_execution)
+    {
+      static char message1[] = "Error in deleting catchpoint %d:\n";
+      static char message[sizeof (message1) + 30];
+      args_for_catchpoint_enable args;
+
+      /* Format possible error msg */
+      sprintf (message, message1, bpt->number);
+      args.kind = bpt->type == bp_catch_catch ? 
+	EX_EVENT_CATCH : EX_EVENT_THROW;
+      args.enable_p = 0;
+      catch_errors (cover_target_enable_exception_callback, &args,
+		    message, RETURN_MASK_ALL);
+    }
+
+
+  ALL_BREAKPOINTS (b)
+    if (b->next == bpt)
+    {
+      b->next = bpt->next;
+      break;
+    }
+
+  check_duplicates (bpt);
+  /* If this breakpoint was inserted, and there is another breakpoint
+     at the same address, we need to insert the other breakpoint.  */
+  if (bpt->inserted
+      && bpt->type != bp_hardware_watchpoint
+      && bpt->type != bp_read_watchpoint
+      && bpt->type != bp_access_watchpoint
+      && bpt->type != bp_catch_fork
+      && bpt->type != bp_catch_vfork
+      && bpt->type != bp_catch_exec)
+    {
+      ALL_BREAKPOINTS (b)
+	if (b->address == bpt->address
+	    && b->section == bpt->section
+	    && !b->duplicate
+	    && b->enable_state != bp_disabled
+	    && b->enable_state != bp_shlib_disabled
+	    && b->enable_state != bp_call_disabled)
+	{
+	  int val;
+
+	  /* We should never reach this point if there is a permanent
+	     breakpoint at the same address as the one being deleted.
+	     If there is a permanent breakpoint somewhere, it should
+	     always be the only one inserted.  */
+	  if (b->enable_state == bp_permanent)
+	    internal_error (__FILE__, __LINE__,
+			    "another breakpoint was inserted on top of "
+			    "a permanent breakpoint");
+
+	  if (b->type == bp_hardware_breakpoint)
+	    val = target_insert_hw_breakpoint (b->address, b->shadow_contents);
+	  else
+	    val = target_insert_breakpoint (b->address, b->shadow_contents);
+
+	  /* If there was an error in the insert, print a message, then stop execution.  */
+	  if (val != 0)
+	    {
+	      struct ui_file *tmp_error_stream = mem_fileopen ();
+	      make_cleanup_ui_file_delete (tmp_error_stream);
+	     
+
+	      if (b->type == bp_hardware_breakpoint)
+		{
+		  fprintf_unfiltered (tmp_error_stream, 
+					"Cannot insert hardware breakpoint %d.\n"
+				      "You may have requested too many hardware breakpoints.\n",
+					b->number);
+		  }
+		else
+		  {
+		    fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number);
+		    fprintf_filtered (tmp_error_stream, "Error accessing memory address ");
+		    print_address_numeric (b->address, 1, tmp_error_stream);
+		    fprintf_filtered (tmp_error_stream, ": %s.\n",
+				      safe_strerror (val));
+		  }
+	      
+	      fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process.");
+	      target_terminal_ours_for_output ();
+	      error_stream(tmp_error_stream); 
+	    }
+	  else
+	    b->inserted = 1;
+	}
+    }
+
+  free_command_lines (&bpt->commands);
+  if (bpt->cond)
+    xfree (bpt->cond);
+  if (bpt->cond_string != NULL)
+    xfree (bpt->cond_string);
+  if (bpt->addr_string != NULL)
+    xfree (bpt->addr_string);
+  if (bpt->exp != NULL)
+    xfree (bpt->exp);
+  if (bpt->exp_string != NULL)
+    xfree (bpt->exp_string);
+  if (bpt->val != NULL)
+    value_free (bpt->val);
+  if (bpt->source_file != NULL)
+    xfree (bpt->source_file);
+  if (bpt->dll_pathname != NULL)
+    xfree (bpt->dll_pathname);
+  if (bpt->triggered_dll_pathname != NULL)
+    xfree (bpt->triggered_dll_pathname);
+  if (bpt->exec_pathname != NULL)
+    xfree (bpt->exec_pathname);
+
+  /* Be sure no bpstat's are pointing at it after it's been freed.  */
+  /* FIXME, how can we find all bpstat's?
+     We just check stop_bpstat for now.  */
+  for (bs = stop_bpstat; bs; bs = bs->next)
+    if (bs->breakpoint_at == bpt)
+      {
+	bs->breakpoint_at = NULL;
+	bs->old_val = NULL;
+	/* bs->commands will be freed later.  */
+      }
+  /* On the chance that someone will soon try again to delete this same
+     bp, we mark it as deleted before freeing its storage. */
+  bpt->type = bp_none;
+
+  xfree (bpt);
+}
+
+static void
+do_delete_breakpoint_cleanup (void *b)
+{
+  delete_breakpoint (b);
+}
+
+struct cleanup *
+make_cleanup_delete_breakpoint (struct breakpoint *b)
+{
+  return make_cleanup (do_delete_breakpoint_cleanup, b);
+}
+
+struct cleanup *
+make_exec_cleanup_delete_breakpoint (struct breakpoint *b)
+{
+  return make_exec_cleanup (do_delete_breakpoint_cleanup, b);
+}
+
+void
+delete_command (char *arg, int from_tty)
+{
+  struct breakpoint *b, *temp;
+
+  dont_repeat ();
+
+  if (arg == 0)
+    {
+      int breaks_to_delete = 0;
+
+      /* Delete all breakpoints if no argument.
+         Do not delete internal or call-dummy breakpoints, these
+         have to be deleted with an explicit breakpoint number argument.  */
+      ALL_BREAKPOINTS (b)
+      {
+	if (b->type != bp_call_dummy &&
+	    b->type != bp_shlib_event &&
+	    b->type != bp_thread_event &&
+	    b->type != bp_overlay_event &&
+	    b->number >= 0)
+	  breaks_to_delete = 1;
+      }
+
+      /* Ask user only if there are some breakpoints to delete.  */
+      if (!from_tty
+	  || (breaks_to_delete && query ("Delete all breakpoints? ")))
+	{
+	  ALL_BREAKPOINTS_SAFE (b, temp)
+	  {
+	    if (b->type != bp_call_dummy &&
+		b->type != bp_shlib_event &&
+		b->type != bp_thread_event &&
+		b->type != bp_overlay_event &&
+		b->number >= 0)
+	      delete_breakpoint (b);
+	  }
+	}
+    }
+  else
+    map_breakpoint_numbers (arg, delete_breakpoint);
+}
+
+/* Reset a breakpoint given it's struct breakpoint * BINT.
+   The value we return ends up being the return value from catch_errors.
+   Unused in this case.  */
+
+static int
+breakpoint_re_set_one (PTR bint)
+{
+  /* get past catch_errs */
+  struct breakpoint *b = (struct breakpoint *) bint;
+  struct value *mark;
+  int i;
+  struct symtabs_and_lines sals;
+  char *s;
+  enum enable_state save_enable;
+
+  switch (b->type)
+    {
+    case bp_none:
+      warning ("attempted to reset apparently deleted breakpoint #%d?",
+	       b->number);
+      return 0;
+    case bp_breakpoint:
+    case bp_hardware_breakpoint:
+    case bp_catch_load:
+    case bp_catch_unload:
+      if (b->addr_string == NULL)
+	{
+	  /* Anything without a string can't be re-set. */
+	  delete_breakpoint (b);
+	  return 0;
+	}
+      /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
+
+	 ``And a hack it is, although Apple's Darwin version of GDB
+	 contains an almost identical hack to implement a "future
+	 break" command.  It seems to work in many real world cases,
+	 but it is easy to come up with a test case where the patch
+	 doesn't help at all.''
+
+	 ``It seems that the way GDB implements breakpoints - in -
+	 shared - libraries was designed for a.out shared library
+	 systems (SunOS 4) where shared libraries were loaded at a
+	 fixed address in memory.  Since ELF shared libraries can (and
+	 will) be loaded at any address in memory, things break.
+	 Fixing this is not trivial.  Therefore, I'm not sure whether
+	 we should add this hack to the branch only.  I cannot
+	 guarantee that things will be fixed on the trunk in the near
+	 future.''
+
+         In case we have a problem, disable this breakpoint.  We'll
+         restore its status if we succeed.  Don't disable a
+         shlib_disabled breakpoint though.  There's a fair chance we
+         can't re-set it if the shared library it's in hasn't been
+         loaded yet.  */
+      save_enable = b->enable_state;
+      if (b->enable_state != bp_shlib_disabled)
+        b->enable_state = bp_disabled;
+
+      set_language (b->language);
+      input_radix = b->input_radix;
+      s = b->addr_string;
+      sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL);
+      for (i = 0; i < sals.nelts; i++)
+	{
+	  resolve_sal_pc (&sals.sals[i]);
+
+	  /* Reparse conditions, they might contain references to the
+	     old symtab.  */
+	  if (b->cond_string != NULL)
+	    {
+	      s = b->cond_string;
+	      if (b->cond)
+		xfree (b->cond);
+	      b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
+	    }
+
+	  /* We need to re-set the breakpoint if the address changes... */
+	  if (b->address != sals.sals[i].pc
+	  /* ...or new and old breakpoints both have source files, and
+	     the source file name or the line number changes...  */
+	      || (b->source_file != NULL
+		  && sals.sals[i].symtab != NULL
+		  && (!STREQ (b->source_file, sals.sals[i].symtab->filename)
+		      || b->line_number != sals.sals[i].line)
+	      )
+	  /* ...or we switch between having a source file and not having
+	     one.  */
+	      || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL))
+	    )
+	    {
+	      if (b->source_file != NULL)
+		xfree (b->source_file);
+	      if (sals.sals[i].symtab == NULL)
+		b->source_file = NULL;
+	      else
+		b->source_file =
+		  savestring (sals.sals[i].symtab->filename,
+			      strlen (sals.sals[i].symtab->filename));
+	      b->line_number = sals.sals[i].line;
+	      b->address = sals.sals[i].pc;
+
+	      /* Used to check for duplicates here, but that can
+	         cause trouble, as it doesn't check for disabled
+	         breakpoints. */
+
+	      mention (b);
+
+	      /* Might be better to do this just once per breakpoint_re_set,
+	         rather than once for every breakpoint.  */
+	      breakpoints_changed ();
+	    }
+	  b->section = sals.sals[i].section;
+	  b->enable_state = save_enable;	/* Restore it, this worked. */
+
+
+	  /* Now that this is re-enabled, check_duplicates
+	     can be used. */
+	  check_duplicates (b);
+
+	}
+      xfree (sals.sals);
+      break;
+
+    case bp_watchpoint:
+    case bp_hardware_watchpoint:
+    case bp_read_watchpoint:
+    case bp_access_watchpoint:
+      innermost_block = NULL;
+      /* The issue arises of what context to evaluate this in.  The
+         same one as when it was set, but what does that mean when
+         symbols have been re-read?  We could save the filename and
+         functionname, but if the context is more local than that, the
+         best we could do would be something like how many levels deep
+         and which index at that particular level, but that's going to
+         be less stable than filenames or function names.  */
+
+      /* So for now, just use a global context.  */
+      if (b->exp)
+	xfree (b->exp);
+      b->exp = parse_expression (b->exp_string);
+      b->exp_valid_block = innermost_block;
+      mark = value_mark ();
+      if (b->val)
+	value_free (b->val);
+      b->val = evaluate_expression (b->exp);
+      release_value (b->val);
+      if (VALUE_LAZY (b->val))
+	value_fetch_lazy (b->val);
+
+      if (b->cond_string != NULL)
+	{
+	  s = b->cond_string;
+	  if (b->cond)
+	    xfree (b->cond);
+	  b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
+	}
+      if (b->enable_state == bp_enabled)
+	mention (b);
+      value_free_to_mark (mark);
+      break;
+    case bp_catch_catch:
+    case bp_catch_throw:
+      break;
+      /* We needn't really do anything to reset these, since the mask
+         that requests them is unaffected by e.g., new libraries being
+         loaded. */
+    case bp_catch_fork:
+    case bp_catch_vfork:
+    case bp_catch_exec:
+      break;
+
+    default:
+      printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
+      /* fall through */
+      /* Delete longjmp and overlay event breakpoints; they will be
+         reset later by breakpoint_re_set.  */
+    case bp_longjmp:
+    case bp_longjmp_resume:
+    case bp_overlay_event:
+      delete_breakpoint (b);
+      break;
+
+      /* This breakpoint is special, it's set up when the inferior
+         starts and we really don't want to touch it.  */
+    case bp_shlib_event:
+
+      /* Like bp_shlib_event, this breakpoint type is special.
+	 Once it is set up, we do not want to touch it.  */
+    case bp_thread_event:
+
+      /* Keep temporary breakpoints, which can be encountered when we step
+         over a dlopen call and SOLIB_ADD is resetting the breakpoints.
+         Otherwise these should have been blown away via the cleanup chain
+         or by breakpoint_init_inferior when we rerun the executable.  */
+    case bp_until:
+    case bp_finish:
+    case bp_watchpoint_scope:
+    case bp_call_dummy:
+    case bp_step_resume:
+      break;
+    }
+
+  return 0;
+}
+
+/* Re-set all breakpoints after symbols have been re-loaded.  */
+void
+breakpoint_re_set (void)
+{
+  struct breakpoint *b, *temp;
+  enum language save_language;
+  int save_input_radix;
+  static char message1[] = "Error in re-setting breakpoint %d:\n";
+  char message[sizeof (message1) + 30 /* slop */ ];
+
+  save_language = current_language->la_language;
+  save_input_radix = input_radix;
+  ALL_BREAKPOINTS_SAFE (b, temp)
+  {
+    /* Format possible error msg */
+    sprintf (message, message1, b->number);
+    catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL);
+  }
+  set_language (save_language);
+  input_radix = save_input_radix;
+
+  if (GET_LONGJMP_TARGET_P ())
+    {
+      create_longjmp_breakpoint ("longjmp");
+      create_longjmp_breakpoint ("_longjmp");
+      create_longjmp_breakpoint ("siglongjmp");
+      create_longjmp_breakpoint ("_siglongjmp");
+      create_longjmp_breakpoint (NULL);
+    }
+  
+  create_overlay_event_breakpoint ("_ovly_debug_event");
+}
+
+/* Reset the thread number of this breakpoint:
+
+   - If the breakpoint is for all threads, leave it as-is.
+   - Else, reset it to the current thread for inferior_ptid. */
+void
+breakpoint_re_set_thread (struct breakpoint *b)
+{
+  if (b->thread != -1)
+    {
+      if (in_thread_list (inferior_ptid))
+	b->thread = pid_to_thread_id (inferior_ptid);
+    }
+}
+
+/* Set ignore-count of breakpoint number BPTNUM to COUNT.
+   If from_tty is nonzero, it prints a message to that effect,
+   which ends with a period (no newline).  */
+
+void
+set_ignore_count (int bptnum, int count, int from_tty)
+{
+  register struct breakpoint *b;
+
+  if (count < 0)
+    count = 0;
+
+  ALL_BREAKPOINTS (b)
+    if (b->number == bptnum)
+    {
+      b->ignore_count = count;
+      if (from_tty)
+	{
+	  if (count == 0)
+	    printf_filtered ("Will stop next time breakpoint %d is reached.",
+			     bptnum);
+	  else if (count == 1)
+	    printf_filtered ("Will ignore next crossing of breakpoint %d.",
+			     bptnum);
+	  else
+	    printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
+			     count, bptnum);
+	}
+      breakpoints_changed ();
+      breakpoint_modify_event (b->number);
+      return;
+    }
+
+  error ("No breakpoint number %d.", bptnum);
+}
+
+/* Clear the ignore counts of all breakpoints.  */
+void
+breakpoint_clear_ignore_counts (void)
+{
+  struct breakpoint *b;
+
+  ALL_BREAKPOINTS (b)
+    b->ignore_count = 0;
+}
+
+/* Command to set ignore-count of breakpoint N to COUNT.  */
+
+static void
+ignore_command (char *args, int from_tty)
+{
+  char *p = args;
+  register int num;
+
+  if (p == 0)
+    error_no_arg ("a breakpoint number");
+
+  num = get_number (&p);
+  if (num == 0)
+    error ("bad breakpoint number: '%s'", args);
+  if (*p == 0)
+    error ("Second argument (specified ignore-count) is missing.");
+
+  set_ignore_count (num,
+		    longest_to_int (value_as_long (parse_and_eval (p))),
+		    from_tty);
+  if (from_tty)
+    printf_filtered ("\n");
+}
+
+/* Call FUNCTION on each of the breakpoints
+   whose numbers are given in ARGS.  */
+
+static void
+map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *))
+{
+  register char *p = args;
+  char *p1;
+  register int num;
+  register struct breakpoint *b, *tmp;
+  int match;
+
+  if (p == 0)
+    error_no_arg ("one or more breakpoint numbers");
+
+  while (*p)
+    {
+      match = 0;
+      p1 = p;
+
+      num = get_number_or_range (&p1);
+      if (num == 0)
+	{
+	  warning ("bad breakpoint number at or near '%s'", p);
+	}
+      else
+	{
+	  ALL_BREAKPOINTS_SAFE (b, tmp)
+	    if (b->number == num)
+	      {
+		struct breakpoint *related_breakpoint = b->related_breakpoint;
+		match = 1;
+		function (b);
+		if (related_breakpoint)
+		  function (related_breakpoint);
+		break;
+	      }
+	  if (match == 0)
+	    printf_unfiltered ("No breakpoint number %d.\n", num);
+	}
+      p = p1;
+    }
+}
+
+/* Set ignore-count of breakpoint number BPTNUM to COUNT.
+   If from_tty is nonzero, it prints a message to that effect,
+   which ends with a period (no newline).  */
+
+void
+disable_breakpoint (struct breakpoint *bpt)
+{
+  /* Never disable a watchpoint scope breakpoint; we want to
+     hit them when we leave scope so we can delete both the
+     watchpoint and its scope breakpoint at that time.  */
+  if (bpt->type == bp_watchpoint_scope)
+    return;
+
+  /* You can't disable permanent breakpoints.  */
+  if (bpt->enable_state == bp_permanent)
+    return;
+
+  bpt->enable_state = bp_disabled;
+
+  check_duplicates (bpt);
+
+  if (modify_breakpoint_hook)
+    modify_breakpoint_hook (bpt);
+  breakpoint_modify_event (bpt->number);
+}
+
+/* ARGSUSED */
+static void
+disable_command (char *args, int from_tty)
+{
+  register struct breakpoint *bpt;
+  if (args == 0)
+    ALL_BREAKPOINTS (bpt)
+      switch (bpt->type)
+      {
+      case bp_none:
+	warning ("attempted to disable apparently deleted breakpoint #%d?",
+		 bpt->number);
+	continue;
+      case bp_breakpoint:
+      case bp_catch_load:
+      case bp_catch_unload:
+      case bp_catch_fork:
+      case bp_catch_vfork:
+      case bp_catch_exec:
+      case bp_catch_catch:
+      case bp_catch_throw:
+      case bp_hardware_breakpoint:
+      case bp_watchpoint:
+      case bp_hardware_watchpoint:
+      case bp_read_watchpoint:
+      case bp_access_watchpoint:
+	disable_breakpoint (bpt);
+      default:
+	continue;
+      }
+  else
+    map_breakpoint_numbers (args, disable_breakpoint);
+}
+
+static void
+do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition)
+{
+  struct frame_info *save_selected_frame = NULL;
+  int save_selected_frame_level = -1;
+  int target_resources_ok, other_type_used;
+  struct value *mark;
+
+  if (bpt->type == bp_hardware_breakpoint)
+    {
+      int i;
+      i = hw_breakpoint_used_count ();
+      target_resources_ok = 
+	TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint, 
+					    i + 1, 0);
+      if (target_resources_ok == 0)
+	error ("No hardware breakpoint support in the target.");
+      else if (target_resources_ok < 0)
+	error ("Hardware breakpoints used exceeds limit.");
+    }
+
+  if (bpt->enable_state != bp_permanent)
+    bpt->enable_state = bp_enabled;
+  bpt->disposition = disposition;
+  check_duplicates (bpt);
+  breakpoints_changed ();
+
+  if (bpt->type == bp_watchpoint || 
+      bpt->type == bp_hardware_watchpoint ||
+      bpt->type == bp_read_watchpoint || 
+      bpt->type == bp_access_watchpoint)
+    {
+      if (bpt->exp_valid_block != NULL)
+	{
+	  struct frame_info *fr =
+	  fr = frame_find_by_id (bpt->watchpoint_frame);
+	  if (fr == NULL)
+	    {
+	      printf_filtered ("\
+Cannot enable watchpoint %d because the block in which its expression\n\
+is valid is not currently in scope.\n", bpt->number);
+	      bpt->enable_state = bp_disabled;
+	      return;
+	    }
+
+	  save_selected_frame = selected_frame;
+	  save_selected_frame_level = frame_relative_level (selected_frame);
+	  select_frame (fr);
+	}
+
+      value_free (bpt->val);
+      mark = value_mark ();
+      bpt->val = evaluate_expression (bpt->exp);
+      release_value (bpt->val);
+      if (VALUE_LAZY (bpt->val))
+	value_fetch_lazy (bpt->val);
+
+      if (bpt->type == bp_hardware_watchpoint ||
+	  bpt->type == bp_read_watchpoint ||
+	  bpt->type == bp_access_watchpoint)
+	{
+	  int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
+	  int mem_cnt = can_use_hardware_watchpoint (bpt->val);
+
+	  /* Hack around 'unused var' error for some targets here */
+	  (void) mem_cnt, i;
+	  target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT (
+				   bpt->type, i + mem_cnt, other_type_used);
+	  /* we can consider of type is bp_hardware_watchpoint, convert to 
+	     bp_watchpoint in the following condition */
+	  if (target_resources_ok < 0)
+	    {
+	      printf_filtered ("\
+Cannot enable watchpoint %d because target watch resources\n\
+have been allocated for other watchpoints.\n", bpt->number);
+	      bpt->enable_state = bp_disabled;
+	      value_free_to_mark (mark);
+	      return;
+	    }
+	}
+
+      if (save_selected_frame_level >= 0)
+	select_frame (save_selected_frame);
+      value_free_to_mark (mark);
+    }
+  if (modify_breakpoint_hook)
+    modify_breakpoint_hook (bpt);
+  breakpoint_modify_event (bpt->number);
+}
+
+void
+enable_breakpoint (struct breakpoint *bpt)
+{
+  do_enable_breakpoint (bpt, bpt->disposition);
+}
+
+/* The enable command enables the specified breakpoints (or all defined
+   breakpoints) so they once again become (or continue to be) effective
+   in stopping the inferior. */
+
+/* ARGSUSED */
+static void
+enable_command (char *args, int from_tty)
+{
+  register struct breakpoint *bpt;
+  if (args == 0)
+    ALL_BREAKPOINTS (bpt)
+      switch (bpt->type)
+      {
+      case bp_none:
+	warning ("attempted to enable apparently deleted breakpoint #%d?",
+		 bpt->number);
+	continue;
+      case bp_breakpoint:
+      case bp_catch_load:
+      case bp_catch_unload:
+      case bp_catch_fork:
+      case bp_catch_vfork:
+      case bp_catch_exec:
+      case bp_catch_catch:
+      case bp_catch_throw:
+      case bp_hardware_breakpoint:
+      case bp_watchpoint:
+      case bp_hardware_watchpoint:
+      case bp_read_watchpoint:
+      case bp_access_watchpoint:
+	enable_breakpoint (bpt);
+      default:
+	continue;
+      }
+  else
+    map_breakpoint_numbers (args, enable_breakpoint);
+}
+
+static void
+enable_once_breakpoint (struct breakpoint *bpt)
+{
+  do_enable_breakpoint (bpt, disp_disable);
+}
+
+/* ARGSUSED */
+static void
+enable_once_command (char *args, int from_tty)
+{
+  map_breakpoint_numbers (args, enable_once_breakpoint);
+}
+
+static void
+enable_delete_breakpoint (struct breakpoint *bpt)
+{
+  do_enable_breakpoint (bpt, disp_del);
+}
+
+/* ARGSUSED */
+static void
+enable_delete_command (char *args, int from_tty)
+{
+  map_breakpoint_numbers (args, enable_delete_breakpoint);
+}
+
+/* Use default_breakpoint_'s, or nothing if they aren't valid.  */
+
+struct symtabs_and_lines
+decode_line_spec_1 (char *string, int funfirstline)
+{
+  struct symtabs_and_lines sals;
+  if (string == 0)
+    error ("Empty line specification.");
+  if (default_breakpoint_valid)
+    sals = decode_line_1 (&string, funfirstline,
+			  default_breakpoint_symtab,
+			  default_breakpoint_line,
+			  (char ***) NULL);
+  else
+    sals = decode_line_1 (&string, funfirstline,
+			  (struct symtab *) NULL, 0, (char ***) NULL);
+  if (*string)
+    error ("Junk at end of line specification: %s", string);
+  return sals;
+}
+
+void
+_initialize_breakpoint (void)
+{
+  struct cmd_list_element *c;
+
+  breakpoint_chain = 0;
+  /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
+     before a breakpoint is set.  */
+  breakpoint_count = 0;
+
+  add_com ("ignore", class_breakpoint, ignore_command,
+	   "Set ignore-count of breakpoint number N to COUNT.\n\
+Usage is `ignore N COUNT'.");
+  if (xdb_commands)
+    add_com_alias ("bc", "ignore", class_breakpoint, 1);
+
+  add_com ("commands", class_breakpoint, commands_command,
+	   "Set commands to be executed when a breakpoint is hit.\n\
+Give breakpoint number as argument after \"commands\".\n\
+With no argument, the targeted breakpoint is the last one set.\n\
+The commands themselves follow starting on the next line.\n\
+Type a line containing \"end\" to indicate the end of them.\n\
+Give \"silent\" as the first line to make the breakpoint silent;\n\
+then no output is printed when it is hit, except what the commands print.");
+
+  add_com ("condition", class_breakpoint, condition_command,
+	   "Specify breakpoint number N to break only if COND is true.\n\
+Usage is `condition N COND', where N is an integer and COND is an\n\
+expression to be evaluated whenever breakpoint N is reached.");
+
+  c = add_com ("tbreak", class_breakpoint, tbreak_command,
+	       "Set a temporary breakpoint.  Args like \"break\" command.\n\
+Like \"break\" except the breakpoint is only temporary,\n\
+so it will be deleted when hit.  Equivalent to \"break\" followed\n\
+by using \"enable delete\" on the breakpoint number.");
+  set_cmd_completer (c, location_completer);
+
+  c = add_com ("hbreak", class_breakpoint, hbreak_command,
+	       "Set a hardware assisted  breakpoint. Args like \"break\" command.\n\
+Like \"break\" except the breakpoint requires hardware support,\n\
+some target hardware may not have this support.");
+  set_cmd_completer (c, location_completer);
+
+  c = add_com ("thbreak", class_breakpoint, thbreak_command,
+	       "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
+Like \"hbreak\" except the breakpoint is only temporary,\n\
+so it will be deleted when hit.");
+  set_cmd_completer (c, location_completer);
+
+  add_prefix_cmd ("enable", class_breakpoint, enable_command,
+		  "Enable some breakpoints.\n\
+Give breakpoint numbers (separated by spaces) as arguments.\n\
+With no subcommand, breakpoints are enabled until you command otherwise.\n\
+This is used to cancel the effect of the \"disable\" command.\n\
+With a subcommand you can enable temporarily.",
+		  &enablelist, "enable ", 1, &cmdlist);
+  if (xdb_commands)
+    add_com ("ab", class_breakpoint, enable_command,
+	     "Enable some breakpoints.\n\
+Give breakpoint numbers (separated by spaces) as arguments.\n\
+With no subcommand, breakpoints are enabled until you command otherwise.\n\
+This is used to cancel the effect of the \"disable\" command.\n\
+With a subcommand you can enable temporarily.");
+
+  add_com_alias ("en", "enable", class_breakpoint, 1);
+
+  add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
+			 "Enable some breakpoints.\n\
+Give breakpoint numbers (separated by spaces) as arguments.\n\
+This is used to cancel the effect of the \"disable\" command.\n\
+May be abbreviated to simply \"enable\".\n",
+		   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
+
+  add_cmd ("once", no_class, enable_once_command,
+	   "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
+	   &enablebreaklist);
+
+  add_cmd ("delete", no_class, enable_delete_command,
+	   "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it is deleted.",
+	   &enablebreaklist);
+
+  add_cmd ("delete", no_class, enable_delete_command,
+	   "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it is deleted.",
+	   &enablelist);
+
+  add_cmd ("once", no_class, enable_once_command,
+	   "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion, it becomes disabled.",
+	   &enablelist);
+
+  add_prefix_cmd ("disable", class_breakpoint, disable_command,
+		  "Disable some breakpoints.\n\
+Arguments are breakpoint numbers with spaces in between.\n\
+To disable all breakpoints, give no argument.\n\
+A disabled breakpoint is not forgotten, but has no effect until reenabled.",
+		  &disablelist, "disable ", 1, &cmdlist);
+  add_com_alias ("dis", "disable", class_breakpoint, 1);
+  add_com_alias ("disa", "disable", class_breakpoint, 1);
+  if (xdb_commands)
+    add_com ("sb", class_breakpoint, disable_command,
+	     "Disable some breakpoints.\n\
+Arguments are breakpoint numbers with spaces in between.\n\
+To disable all breakpoints, give no argument.\n\
+A disabled breakpoint is not forgotten, but has no effect until reenabled.");
+
+  add_cmd ("breakpoints", class_alias, disable_command,
+	   "Disable some breakpoints.\n\
+Arguments are breakpoint numbers with spaces in between.\n\
+To disable all breakpoints, give no argument.\n\
+A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
+This command may be abbreviated \"disable\".",
+	   &disablelist);
+
+  add_prefix_cmd ("delete", class_breakpoint, delete_command,
+		  "Delete some breakpoints or auto-display expressions.\n\
+Arguments are breakpoint numbers with spaces in between.\n\
+To delete all breakpoints, give no argument.\n\
+\n\
+Also a prefix command for deletion of other GDB objects.\n\
+The \"unset\" command is also an alias for \"delete\".",
+		  &deletelist, "delete ", 1, &cmdlist);
+  add_com_alias ("d", "delete", class_breakpoint, 1);
+  if (xdb_commands)
+    add_com ("db", class_breakpoint, delete_command,
+	     "Delete some breakpoints.\n\
+Arguments are breakpoint numbers with spaces in between.\n\
+To delete all breakpoints, give no argument.\n");
+
+  add_cmd ("breakpoints", class_alias, delete_command,
+	   "Delete some breakpoints or auto-display expressions.\n\
+Arguments are breakpoint numbers with spaces in between.\n\
+To delete all breakpoints, give no argument.\n\
+This command may be abbreviated \"delete\".",
+	   &deletelist);
+
+  add_com ("clear", class_breakpoint, clear_command,
+	   concat ("Clear breakpoint at specified line or function.\n\
+Argument may be line number, function name, or \"*\" and an address.\n\
+If line number is specified, all breakpoints in that line are cleared.\n\
+If function is specified, breakpoints at beginning of function are cleared.\n\
+If an address is specified, breakpoints at that address are cleared.\n\n",
+		   "With no argument, clears all breakpoints in the line that the selected frame\n\
+is executing in.\n\
+\n\
+See also the \"delete\" command which clears breakpoints by number.", NULL));
+
+  c = add_com ("break", class_breakpoint, break_command,
+	       concat ("Set breakpoint at specified line or function.\n\
+Argument may be line number, function name, or \"*\" and an address.\n\
+If line number is specified, break at start of code for that line.\n\
+If function is specified, break at start of code for that function.\n\
+If an address is specified, break at that exact address.\n",
+		   "With no arg, uses current execution address of selected stack frame.\n\
+This is useful for breaking on return to a stack frame.\n\
+\n\
+Multiple breakpoints at one place are permitted, and useful if conditional.\n\
+\n\
+Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
+  set_cmd_completer (c, location_completer);
+
+  add_com_alias ("b", "break", class_run, 1);
+  add_com_alias ("br", "break", class_run, 1);
+  add_com_alias ("bre", "break", class_run, 1);
+  add_com_alias ("brea", "break", class_run, 1);
+
+ if (xdb_commands)
+    {
+      add_com_alias ("ba", "break", class_breakpoint, 1);
+      add_com_alias ("bu", "ubreak", class_breakpoint, 1);
+    }
+
+  if (dbx_commands)
+    {
+      add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command,
+	"Break in function/address or break at a line in the current file.",
+			     &stoplist, "stop ", 1, &cmdlist);
+      add_cmd ("in", class_breakpoint, stopin_command,
+	       "Break in function or address.\n", &stoplist);
+      add_cmd ("at", class_breakpoint, stopat_command,
+	       "Break at a line in the current file.\n", &stoplist);
+      add_com ("status", class_info, breakpoints_info,
+	       concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
+The \"Type\" column indicates one of:\n\
+\tbreakpoint     - normal breakpoint\n\
+\twatchpoint     - watchpoint\n\
+The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
+the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
+breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
+address and file/line number respectively.\n\n",
+		       "Convenience variable \"$_\" and default examine address for \"x\"\n\
+are set to the address of the last breakpoint listed.\n\n\
+Convenience variable \"$bpnum\" contains the number of the last\n\
+breakpoint set.", NULL));
+    }
+
+  add_info ("breakpoints", breakpoints_info,
+	    concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
+The \"Type\" column indicates one of:\n\
+\tbreakpoint     - normal breakpoint\n\
+\twatchpoint     - watchpoint\n\
+The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
+the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
+breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
+address and file/line number respectively.\n\n",
+		    "Convenience variable \"$_\" and default examine address for \"x\"\n\
+are set to the address of the last breakpoint listed.\n\n\
+Convenience variable \"$bpnum\" contains the number of the last\n\
+breakpoint set.", NULL));
+
+  if (xdb_commands)
+    add_com ("lb", class_breakpoint, breakpoints_info,
+	     concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
+The \"Type\" column indicates one of:\n\
+\tbreakpoint     - normal breakpoint\n\
+\twatchpoint     - watchpoint\n\
+The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
+the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
+breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
+address and file/line number respectively.\n\n",
+		     "Convenience variable \"$_\" and default examine address for \"x\"\n\
+are set to the address of the last breakpoint listed.\n\n\
+Convenience variable \"$bpnum\" contains the number of the last\n\
+breakpoint set.", NULL));
+
+  add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
+	   concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
+The \"Type\" column indicates one of:\n\
+\tbreakpoint     - normal breakpoint\n\
+\twatchpoint     - watchpoint\n\
+\tlongjmp        - internal breakpoint used to step through longjmp()\n\
+\tlongjmp resume - internal breakpoint at the target of longjmp()\n\
+\tuntil          - internal breakpoint used by the \"until\" command\n\
+\tfinish         - internal breakpoint used by the \"finish\" command\n",
+		   "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
+the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
+breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
+address and file/line number respectively.\n\n",
+		   "Convenience variable \"$_\" and default examine address for \"x\"\n\
+are set to the address of the last breakpoint listed.\n\n\
+Convenience variable \"$bpnum\" contains the number of the last\n\
+breakpoint set.", NULL),
+	   &maintenanceinfolist);
+
+  add_com ("catch", class_breakpoint, catch_command,
+	   "Set catchpoints to catch events.\n\
+Raised signals may be caught:\n\
+\tcatch signal              - all signals\n\
+\tcatch signal <signame>    - a particular signal\n\
+Raised exceptions may be caught:\n\
+\tcatch throw               - all exceptions, when thrown\n\
+\tcatch throw <exceptname>  - a particular exception, when thrown\n\
+\tcatch catch               - all exceptions, when caught\n\
+\tcatch catch <exceptname>  - a particular exception, when caught\n\
+Thread or process events may be caught:\n\
+\tcatch thread_start        - any threads, just after creation\n\
+\tcatch thread_exit         - any threads, just before expiration\n\
+\tcatch thread_join         - any threads, just after joins\n\
+Process events may be caught:\n\
+\tcatch start               - any processes, just after creation\n\
+\tcatch exit                - any processes, just before expiration\n\
+\tcatch fork                - calls to fork()\n\
+\tcatch vfork               - calls to vfork()\n\
+\tcatch exec                - calls to exec()\n\
+Dynamically-linked library events may be caught:\n\
+\tcatch load                - loads of any library\n\
+\tcatch load <libname>      - loads of a particular library\n\
+\tcatch unload              - unloads of any library\n\
+\tcatch unload <libname>    - unloads of a particular library\n\
+The act of your program's execution stopping may also be caught:\n\
+\tcatch stop\n\n\
+C++ exceptions may be caught:\n\
+\tcatch throw               - all exceptions, when thrown\n\
+\tcatch catch               - all exceptions, when caught\n\
+\n\
+Do \"help set follow-fork-mode\" for info on debugging your program\n\
+after a fork or vfork is caught.\n\n\
+Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
+
+  add_com ("tcatch", class_breakpoint, tcatch_command,
+	   "Set temporary catchpoints to catch events.\n\
+Args like \"catch\" command.\n\
+Like \"catch\" except the catchpoint is only temporary,\n\
+so it will be deleted when hit.  Equivalent to \"catch\" followed\n\
+by using \"enable delete\" on the catchpoint number.");
+
+  c = add_com ("watch", class_breakpoint, watch_command,
+	       "Set a watchpoint for an expression.\n\
+A watchpoint stops execution of your program whenever the value of\n\
+an expression changes.");
+  set_cmd_completer (c, location_completer);
+
+  c = add_com ("rwatch", class_breakpoint, rwatch_command,
+	       "Set a read watchpoint for an expression.\n\
+A watchpoint stops execution of your program whenever the value of\n\
+an expression is read.");
+  set_cmd_completer (c, location_completer);
+
+  c = add_com ("awatch", class_breakpoint, awatch_command,
+	       "Set a watchpoint for an expression.\n\
+A watchpoint stops execution of your program whenever the value of\n\
+an expression is either read or written.");
+  set_cmd_completer (c, location_completer);
+
+  add_info ("watchpoints", breakpoints_info,
+	    "Synonym for ``info breakpoints''.");
+
+
+  c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger,
+		   (char *) &can_use_hw_watchpoints,
+		   "Set debugger's willingness to use watchpoint hardware.\n\
+If zero, gdb will not use hardware for new watchpoints, even if\n\
+such is available.  (However, any hardware watchpoints that were\n\
+created before setting this to nonzero, will continue to use watchpoint\n\
+hardware.)",
+		   &setlist);
+  add_show_from_set (c, &showlist);
+
+  can_use_hw_watchpoints = 1;
+}
diff --git a/gdb/mi/ChangeLog b/gdb/mi/ChangeLog
new file mode 100644
index 0000000..51d9973
--- /dev/null
+++ b/gdb/mi/ChangeLog
@@ -0,0 +1,1836 @@
+2002-09-11  Keith Seitz  <keiths@redhat.com>
+
+	* mi-main.c (mi_cmd_data_list_register_names): Use cleanups
+	for the uiout list. Do the cleanups when returning an error.
+	(mi_cmd_data_list_changed_registers): Ditto.
+	(mi_cmd_data_list_register_values): Use cleanups for the uiout list
+	and tuples. Do the cleanups when returning errors.
+
+2002-07-29  Andrew Cagney  <ac131313@redhat.com>
+
+
+	* mi-cmd-var.c: Include "gdb_string.h".
+	* mi-cmd-disas.c: Ditto.
+
+2002-06-17  Keith Seitz  <keiths@redhat.com>
+
+	* gdbmi.texinfo: Update command examples with real MI behavior.
+
+2002-05-20  Keith Seitz  <keiths@redhat.com>
+
+	* mi-main.c (captured_mi_execute_command): Add uiout parameter.
+	"data" is now a structure which is used to pass data to/from this
+	function to mi_execute_command.
+	Modify function to comply with requirements from catch_exceptions.
+	Store real return result and command's return result in data.
+	(mi_execute_command): Use catch_exceptions.
+	Use enum to handle actions to be performed instead of overloading
+	catch_errors return result and the mi return result.
+
+2002-04-14  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_exec_return): 
+
+2002-04-09  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (register_changed_p): Use frame_register_read instead
+	of read_relative_register_raw_bytes.
+	(get_register): Delete out-of-date comment.
+
+2002-04-07  Elena Zannoni  <ezannoni@redhat.com>
+
+        * mi-cmd-disas.c: Run through indent.
+
+2002-04-07  Elena Zannoni  <ezannoni@redhat.com>
+
+        * mi-cmd-disas.c (dump_insns): New function.
+        (do_mixed_source_and_assembly): New function.
+        (do_assembly_only): New function.
+        (do_disassembly): New function.
+        (mi_cmd_disassemble): Rewrite using smaller, more modular
+        functions.
+
+2002-04-05  Jim Blandy  <jimb@redhat.com>
+
+	* mi-cmd-stack.c (list_args_or_locals): Pass new arg to
+	get_frame_block.  (See entry in gdb/ChangeLog.)
+
+2002-04-05  Elena Zannoni  <ezannoni@redhat.com>
+
+	* mi-cmd-disas.c (mi_cmd_disassemble): Use TARGET_PRINT_INSN
+	instead of tm_print_insn.
+	Update copyright year.
+
+2002-04-04  Daniel Jacobowitz  <drow@mvista.com>
+
+	* mi-cmd-disas.c (mi_cmd_disassemble): Skip end-of-function
+	markers in the line table.
+
+2002-03-15  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (XMALLOC): Delete macro.
+	* mi-out.c (XMALLOC): Ditto.
+	* mi-parse.c (XMALLOC): Ditto.
+	* mi-console.c (XMALLOC): Ditto.
+	* mi-cmd-var.c (XMALLOC): Ditto.
+	* mi-cmd-break.c (XMALLOC): Ditto.
+	
+	* mi/mi-cmd-var.c, mi/mi-console.c, mi/mi-out.c: Update copyright
+	* mi/mi-parse.c: Ditto.
+
+2002-02-24  Andrew Cagney  <ac131313@redhat.com>
+
+	From wiz at danbala:
+	* gdbmi.texinfo: Fix grammar and typos.
+	Fix PR gdb/287.
+
+2002-02-03  Jim Blandy  <jimb@redhat.com>
+
+	* mi-cmd-stack.c (list_args_or_locals): Move declaration of
+	print_me inside the loop body, so it gets re-initialized every
+	iteration.  The cases for the different symbol kinds leave
+	print_me unchanged if they don't want the symbol printed.
+
+2002-01-22  Andrew Cagney  <ac131313@redhat.com>
+
+	* gdbmi.texinfo: Remove makeinfo 3.12 hacks.
+
+2002-01-21  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-cmd-stack.c: Remove #else clause of #ifdef UI_OUT.
+	* mi-cmd-break.c: Ditto.
+	* mi-main.c: Ditto.
+
+2001-12-30  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* gdbmi.texinfo: Fix the application of GFDL in the Copyright notice.
+
+2001-10-12  Daniel Jacobowitz  <drow@mvista.com>
+
+	* mi-cmd-stack.c (list_args_or_locals): Use ALL_BLOCK_SYMBOLS.
+
+2001-09-18  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_thread_select): Pass uiout to
+	gdb_thread_select.
+	(mi_cmd_thread_list_ids): Pass uiout to gdb_list_thread_ids.
+
+	* mi-cmd-break.c (breakpoint_notify): Pass uiout to
+	gdb_breakpoint_query.
+
+2001-08-17  Keith Seitz  <keiths@redhat.com>
+
+	* mi-cmd-var.c (varobj_update_one): Update call to
+	varobj_update to reflect recent api change.
+
+2001-07-26  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c: Include "gdb.h".
+	* mi-cmd-break.c: Include "gdb.h".
+
+2001-07-12  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_execute_command): Flush output after ``(gdb)''
+	prompt.  Bug reported by David Whedon.
+	(mi_execute_async_cli_command): Ditto.
+	(mi_exec_async_cli_cmd_continuation): Ditto.
+	(mi_command_loop): Ditto.
+
+2001-07-10  Mark Kettenis  <kettenis@gnu.org>
+
+	* mi-out.c (mi_out_new): Initialize suppress_ouput field of newly
+	created `struct ui_out_data'.
+
+2001-07-09  Kevin Buettner  <kevinb@redhat.com>
+
+	* mi-main.c (register_changed_p, get_register): Use alloca()
+	to allocate space previously allocated via gcc's
+	variable-length array extension.
+	(mi_cmd_data_write_register_values, mi_cmd_data_write_memory):
+	Change type of ``buffer'' to ``void *''.  Don't cast return value
+	from xmalloc().  Add a cleanup to free the xmalloc'd buffer.
+
+2001-07-07  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_data_evaluate_expression): Replace value_ptr
+	with `struct value *'.
+
+2001-07-08  Kevin Buettner  <kevinb@redhat.com>
+
+	* mi-out.c (mi_table_header, mi_field_int, mi_field_skip)
+	(mi_field_string) Make function declarators match earlier
+	declarations.
+
+2001-07-04  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_ui_out_impl): Initialize is_mi_like_p to one.
+
+2001-06-27  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_table_begin): Include nr_cols and nr_rows in mi1
+	table output.
+	* mi-out.c (mi_table_begin): Only suppress output when mi0. Change
+	the header to a list.
+	(mi_table_body): For mi1, close the header list and open a table
+	body list.
+	(mi_table_end): For mi1, close the body list.
+	(mi_table_header): For mi1, output a tuple containing all the
+	header information.
+	(mi_open, mi_close): Reverse logic of mi_version test.
+	* gdbmi.texinfo (GDB/MI Breakpoint Table Commands): Update.
+
+2001-06-26  Andrew Cagney  <ac131313@redhat.com>
+
+	* gdbmi.texinfo (GDB/MI Output Syntax): Delete reference to query
+	packet.
+
+2001-06-26  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-cmd-stack.c (list_args_or_locals): Output a list of "args" or
+	"locals" entries.
+	* gdbmi.texinfo (stack-list-locals, stack-list-arguments)
+	(exec-interrupt, target-select, thread-select): Update
+	documentation.
+
+2001-06-26  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-cmd-stack.c (mi_cmd_stack_list_frames): Output a list of
+	"stack" entries.
+	(mi_cmd_stack_list_args): Ditto for "stack-args".
+	* gdbmi.texinfo (stack-list-frames, stack-list-arguments): Update
+	documentation.
+	(GDB/MI Stack Manipulation Commands): Fix section title.  Was
+	Stack Manipulation Commands in GDB/MI.
+
+2001-06-25  Andrew Cagney  <ac131313@redhat.com>
+
+	* gdbmi.texinfo: Update output examples that contain stop reason
+	output, change the args=.... to a list.
+	(exec-return): Ditto.
+
+2001-06-25  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_data_read_memory): Output the memory contents
+	- memory and data - as a list.
+	* gdbmi.texinfo (data-read-memory): Update documentation.
+
+2001-06-25  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_data_list_register_values): Output a list of
+	register values.
+	* gdbmi.texinfo (data-list-register-values): Update documentation.
+
+2001-06-25  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_data_list_register_names): Output a list of
+	register names.
+	(mi_cmd_data_list_register_names): Include the pseudo registers.
+	(mi_cmd_data_list_register_names): Don't leave holes in the list,
+	output "" for NULL registers.
+	* gdbmi.texinfo (data-list-register-names): Update documentation.
+
+2001-06-23  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_data_list_changed_registers): Output a list of
+	register numbers.
+	* gdbmi.texinfo (data-list-changed-registers): Update
+	documentation.
+	
+2001-06-23  Andrew Cagney  <ac131313@redhat.com>
+
+	* gdbmi.texinfo (data-disassemble): Update documentation of
+	output.  Produces a list of instructions and a list of source
+	lines.
+
+2001-06-22  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-cmd-disas.c (mi_cmd_disassemble): For "-data-disassemble",
+	output a list instead of a tupple.
+
+2001-06-21  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (struct ui_out_data): Replace field first_header with
+	suppress_output.
+	(mi_begin, mi_end): Check suppress_header.
+	(mi_field_int, mi_field_skip): Ditto.
+	(mi_field_string, mi_field_fmt): Ditto.
+	(mi_table_begin): When nr_rows is zero, set suppress_header else,
+	output the start of the header.
+	(mi_table_body): Clear suppress header.
+
+2001-06-21  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_open): For lists, when mi_version > 0, use ``[''.
+	(mi_close): Ditto for ``]''.
+
+2001-06-20  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_table_header): Add parameter ``col_name''.
+
+2001-06-18  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c: Include "gdb_assert.h".
+	(mi_table_begin): Add parameter ``nr_rows''.
+
+2001-06-18  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c: Use strncmp as the "mi" test.  Allow "mi", "mi0" and
+	"mi1".
+	(mi_command_loop): Add parameter mi_version, pass to mi_out_new.
+	(mi1_command_loop, mi0_command_loop): New functions.
+	(_initialize_mi_main): Recognize "mi", "mi0" and "mi1".
+	* mi-out.c (mi_out_new): Add parameter mi_version.
+	(struct ui_out_data): Add field mi_version.
+	* mi-out.h (mi_out_new): Update.
+
+2001-06-07  Andrew Cagney  <ac131313@redhat.com>
+
+	* gdbmi.texinfo (GDB/MI Output Syntax): Add tuples and lists to
+	syntax.
+	(GDB/MI Draft Changes to Output Syntax): Delete section.
+	
+Mon Jun 11 17:22:25 2001  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-out.c: Fix typo. s/supress/suppress/.
+
+2001-06-09  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_table_end, mi_table_begin, mi_begin, mi_end): Move
+	supress_field_separator updates from here.
+	(mi_open, mi_close): To here.
+	(mi_open): Add parameter name. Output a field_separator.
+	(mi_table_begin): Update.
+	(mi_table_header): Update.
+	(mi_begin): Update.
+
+2001-06-09  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_table_begin): Make char* parameters constant.
+	(mi_table_header): Ditto.
+	(mi_field_int): Ditto.
+	(mi_field_skip): Ditto.
+	(mi_field_string): Ditto.
+	(mi_field_fmt): Ditto.
+	(mi_text): Ditto.
+	(mi_message): Ditto.
+
+2001-05-12  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_close, mi_open): Output ``[]'' when a list.
+
+Fri May 11 13:55:07 2001  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmd-var.c: Replace ui_out_list_begin, ui_out_list_end and
+ 	make_cleanup_ui_out_list_end with ui_out_tupple_begin,
+ 	ui_out_tupple_end and make_cleanup_ui_out_tupple_begin_end.
+	* mi-cmd-stack.c: Ditto.
+	* mi-cmd-disas.c: Ditto.
+	* mi-main.c: Ditto.
+
+2001-05-10  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_open, mi_close): Replace list_open and list_close.
+	(mi_table_begin): Update.
+	(mi_table_header): Update.
+	(mi_begin): Update.
+	(mi_table_body): Update.
+	(mi_table_end): Update.
+	(mi_end): Update.
+
+Thu May 10 16:28:13 2001  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_execute_async_cli_command): Always initialize
+ 	old_cleanups.
+
+2001-05-08  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.c (mi_begin, mi_end): Replace mi_list_begin and
+	mi_list_end.
+	(mi_ui_out_impl): Update.
+
+2001-03-28  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_data_read_memory): Use xcalloc.
+
+2001-03-26  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* gdbmi.texinfo: Update copyright.  Change Permissions to GFDL.
+
+2001-03-20  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-cmd-disas.c (mi_cmd_disassemble): Initialize ``file_string''
+	and ``line_num''.  Consolidate declaration of argument variables.
+
+2001-03-19  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-out.h: Remove #ifdef __STDC__.
+
+2001-03-08  Andrew Cagney  <ac131313@redhat.com>
+
+	* mi-main.c (mi_cmd_data_list_register_names): Use NUM_REGS, not
+	ARCH_NUM_REGS.
+	(mi_cmd_data_list_changed_registers): Ditto.
+	(mi_cmd_data_list_register_values): Ditto.
+	(mi_cmd_data_write_register_values): Ditto.
+
+2001-03-06  Kevin Buettner  <kevinb@redhat.com>
+
+	* gdbmi.texinfo, mi-cmd-disas.c, mi-cmd-stack.c, mi-cmd-var.c,
+	mi-cmds.c, mi-cmds.h, mi-console.c, mi-console.h, mi-getopt.c,
+	mi-getopt.h, mi-out.c, mi-out.h, mi-parse.c, mi-parse.h: 
+	Update/correct copyright notices.
+
+Wed Feb  7 19:50:37 2001  Andrew Cagney  <cagney@redhat.com>
+
+	* mi-getopt.c: Add __FILE__ and __LINE__ parameter to calls to
+ 	internal_error.
+	* mi-console.c: Ditto.
+	* mi-cmds.c: Ditto.
+	* mi-cmd-break.c: Ditto.
+
+2001-01-27  Fernando Nasser  <fnasser@redhat.com>
+
+	From Momchil Velikov  <velco@fadata.bg>
+	* mi-cmd-disas.c (gdb_dis_asm_read_memory): Add missing memory
+	attributes argument in the call to `xfer_memory'.
+
+2000-12-14  Kevin Buettner  <kevinb@redhat.com>
+
+	* mi-cmd-disas.c, mi-cmd-var.c, mi-console.c, mi-main.c,
+	mi-parse.c: Replace occurrences of free() with xfree().
+
+Fri Nov 17 16:07:23 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c: Replace asprintf with xasprintf.
+	* mi-cmd-var.c (mi_cmd_var_create): Ditto.
+
+2000-10-16  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* gdbmi.texinfo (GDB/MI Variable Objects): Dimensions of
+	multitable changed to "@columnfractions .4 .6".  Suggested by
+	Dmitry Sivachenko <dima@Chg.RU>.
+
+2000-08-23  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* gdbmi.texinfo: Change flathead -> @sc{gdb/mi}.
+	Fix typos and markup mistakes (from Dmitry S.
+	Sivachenko <dima@Chg.RU>).
+
+2000-07-24  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* gdbmi.texinfo: Change GDB -> @value{GDBN}, and
+	(gdb) -> (@value{GDBP}).  Fix a few typos and some markup.  From
+	Dmitry S. Sivachenko <dima@Chg.RU>.
+
+Tue May 16 14:13:41 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_cmd_execute): Use free_current_contents.
+	(free_and_reset): Delete.
+
+Mon May 15 16:17:56 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_cmd_data_assign, mi_cmd_data_evaluate_expression),
+ 	mi-cmd-var.c (mi_cmd_var_create, mi_cmd_var_delete): Delete
+ 	make_cleanup_func casts. Not needed.
+
+2000-05-07  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* gdbmi.texinfo: Lots of typos and grammar fixes from Brian
+        Youmans <3diff@flib.gnu.ai.mit.edu>.
+
+Wed Apr 26 18:35:19 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* gdbmi.texinfo (GDB/MI Output Syntax v2.0): Convert Draft 2.0
+ 	Output Syntax into a new section.  Cross reference.
+	(menu): Fix tipo. GDB/MI Compatibility with CLI.
+
+2000-04-23  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* gdbmi.texinfo: Lots of changes, to include this document as part
+	of the GDB manual.
+
+2000-03-13  James Ingham  <jingham@leda.cygnus.com>
+
+	* mi-cmd-var.c (mi_cmd_var_create): Add special frame cookie "@"
+	to indicate an "USE_CURRENT_FRAME" variable.
+	(varobj_update_one): Add "in_scope" and "type_changed" to the
+	result.
+
+2000-03-06  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.h: Export mi_cmd_data_write_register_values.
+	
+	* mi-cmds.c (mi_cmds): Implement data-write-register-values with
+ 	mi_cmd_data_write_register_values.
+
+	* mi-main.c (mi_cmd_data_write_register_values): New
+ 	function. Write a value into a register.
+
+2000-03-06  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Update data-disassemble documentation.
+
+2000-03-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmd-disas.c (mi_cmd_disassemble): Use
+ 	ui_out_field_core_addr() instead of print_address_numeric(), to
+ 	maintain consistency throughout MI.
+
+Wed Feb 23 17:09:39 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmd-break.c, mi-cmd-disas.c, mi-cmd-stack.c, mi-cmd-var.c,
+ 	mi-cmds.c, mi-cmds.h, mi-console.c, mi-console.h, mi-getopt.c,
+ 	mi-getopt.h, mi-main.c, mi-out.c, mi-out.h, mi-parse.c,
+ 	mi-parse.h: Update copyright information.
+
+Wed Feb 23 13:31:16 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmd-disas.c (gdb_dis_asm_read_memory): Change LEN to unsigned
+ 	long.  Match ../include/dis-asm.h change.
+
+Wed Feb 23 10:30:55 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* gdbmi.texinfo: Update copyright - FSF.  Update version
+ 	information.
+
+	mi-cmd-break.c, mi-cmd-disas.c, mi-cmd-stack.c, mi-cmd-var.c,
+ 	mi-cmds.h, mi-main.c, mi-parse.c, mi-parse.h: Re-format using GNU
+ 	indent.
+
+2000-02-21  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c: Add include of gdbcore.h for write_memory()
+ 	prototype.
+
+2000-02-18  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmd-disas.c (mi_cmd_disassemble): Change syntax of
+ 	command. Now use options.  
+	Instead of printing the symbolic address of instructions via
+ 	print_address_symbolic(), use build_address_symbolic() and format
+ 	properly for output.
+	(gdb_do_disassmble): Delete.
+
+2000-02-18  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmd-disas.c (mi_cmd_disassemble): 
+
+2000-02-17  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_data_write_memory): New function. Write a
+ 	value into target memory.
+
+	* mi-cmds.h (mi_cmd_data_write_memory): Export. 
+
+	* mi-cmds.c (mi_cmds): Hook up data-write-memory to
+ 	mi_cmd_data_write_memory().
+
+2000-02-17  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_target_download): Correct error message to
+ 	report right function name.
+	(mi_cmd_target_select): Add doing exec cleanups at end.
+	(mi_cmd_data_read_memory): Correct typo.
+	(mi_cmd_execute): Do not simply free last_async_command, but reset
+ 	it to NULL as well.
+	(free_and_reset): New function, free the argument and set it to
+ 	NULL.
+	(mi_cmd_target_select_continuation): Delete prototype.
+	
+Tue Feb  1 00:17:12 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmd-disas.c, mi-cmds.h, mi-console.c, mi-console.h,
+ 	mi-main.c, mi-out.c, mi-out.h: Update to reflect rename of
+ 	gdb-file / GDB_FILE to ui-file / ``struct ui_file''.
+	
+Mon Jan 31 18:33:28 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_command_loop): Delete reference to
+ 	fputs_unfiltered_hook.
+
+2000-01-27  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.c (mi_cmds): Update entries for
+ 	mi_cmd_data_list_register_names,
+ 	mi_cmd_data_list_changed_registers,
+ 	mi_cmd_data_list_register_values.
+
+	* mi-cmds.h (mi_cmd_data_list_register_names,
+ 	mi_cmd_data_list_changed_registers,
+ 	mi_cmd_data_list_register_values): Update to mi_cmd_argv_ftype.
+
+	* mi-main.c (mi_cmd_data_list_register_names,
+ 	mi_cmd_data_list_changed_registers,
+ 	mi_cmd_data_list_register_values): Update to use argc, argv
+ 	parameters.
+	
+2000-01-27  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_data_read_memory): Correct the computation of
+ 	next-row.
+
+2000-01-27  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-cmd-var.c (mi_cmd_var_create): Test for NULL type.
+	(mi_cmd_var_set_format, mi_cmd_var_show_format,
+	mi_cmd_var_info_num_children, mi_cmd_var_list_children,
+	mi_cmd_var_info_type, mi_cmd_var_info_expression,
+	mi_cmd_var_show_attributes, mi_cmd_var_evaluate_expression,
+	mi_cmd_var_assign, mi_cmd_var_update): Prevent possibility of memory
+	leak on error.
+
+2000-01-27  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-out.c (mi_field_string): Test for NULL string pointer.
+
+2000-01-17  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmd-stack.c (mi_cmd_stack_list_frames): Call
+ 	print_frmae_info() with the correct arguments.
+
+	* mi-main.c (mi_cmd_exec_return): Call
+ 	show_and_print_stack_frame() with LOC_AND_ADDRESS, so it does the
+ 	right thing.  Update Copyright.
+
+2000-01-13  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c: Move disassemble commands from here.
+
+	* mi-cmd-disas.c: To here. New file.
+
+2000-01-13  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmd-stack.c: Remove include of mi-out.h.
+
+	* mi-main.c (mi_cmd_disassemble): Update function to use argc/argv
+ 	interface.
+
+	* mi-cmds.h: Ditto.
+
+	* mi-cmds.c: Ditto.
+
+2000-01-12  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Update stack commands descriptions.
+	Add thread commands descriptions and examples.
+
+	* mi-main.c (mi_cmd_thread_list_ids): Fix typo.
+
+2000-01-12  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_thread_list_ids): New function, print a list
+ 	of currently known threads ids, and the total number of threads.
+	(mi_cmd_thread_select): New function. Switch current thread.
+
+	* mi-cmds.c (mi_cmds): Implement thread-list-ids by
+ 	mi_cmd_thread_list_ids, and thread-select by mi_cmd_thread_select.
+
+	* mi-cmds.h (mi_cmd_thread_select, mi_cmd_thread_list_ids): Export.
+
+2000-01-11  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c: Move stack commands from here.
+
+	* mi-cmd-stack.c: To here. New file.
+
+2000-01-07  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (list_args_or_locals): Add a new paramter, the frame
+ 	for which to display args or locals. Don't use selected_frame
+ 	anymore, use the new parameter instead. Return void instead of
+ 	mi_cmd_result, let callers do so.
+	(mi_cmd_stack_list_args): Change interface. Now accept low and
+ 	high frame numbers to display args for a range of frames. Without
+ 	these two, display args for the whole stack.
+	(mi_cmd_stack_list_locals): Adapt to new interface for
+ 	list_args_or_locals.
+
+2000-01-06  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_stack_info_depth, mi_cmd_stack_list_args,
+ 	mi_cmd_stack_list_frames, mi_cmd_stack_list_locals,
+ 	mi_cmd_stack_select_frame): Change to use argv type of parameters.
+
+	* mi-cmds.c (mi_cmds): Change stack-info-depth,
+ 	stack-list-arguments, stack-list-frames, stack-list-locals,
+ 	stack-select-frame to use argv parameters.
+
+	* mi-cmds.h (mi_cmd_stack_info_depth, mi_cmd_stack_list_args,
+ 	mi_cmd_stack_list_frames, mi_cmd_stack_list_locals,
+ 	mi_cmd_stack_select_frame): Update definitions.
+
+Tue Jan  4 12:38:54 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_command_loop): Force the MI interface to use seven
+ 	bit strings.
+	* gdbmi.texinfo: Make it clear that a quoted C string is seven
+ 	bit.
+
+Thu Dec 30 14:15:22 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-getopt.c (mi_getopt): Rewrite.  Allow long options.
+	* mi-getopt.h (struct mi_opt): Declare.
+	(mi_getopt): Update.
+
+	* mi-main.c (mi_cmd_data_read_memory), mi-cmd-break.c
+ 	(mi_cmd_break_insert, mi_cmd_break_watch): Update.
+
+Wed Dec 29 23:38:35 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmd-break.c (mi_cmd_break_insert): Add support for -c
+ 	<condition>, -i <ignore-count> and -p <thread>.
+	(breakpoint_notify): New function.
+	(mi_cmd_break_insert): Wrap GDB call with callback hooks so that
+ 	MI is notified when ever a breakpoint is created.
+
+	* gdbmi.texinfo: Update.
+
+Fri Dec 24 11:23:22 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (gdb_do_disassemble): Strip out more useless #ifdef
+ 	UI_OUTs.
+
+1999-12-23  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (gdb_do_disassemble): Fix output. Lines that have no
+ 	assembly instructions must still be outputted, to keep the source
+ 	line numbering correct.
+	Remove #ifdef UI_OUT's, they are useless.
+
+1999-12-17  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (gdb_do_disassemble): Don't print a new list in mixed
+ 	mode, every time. Just do it when we actually encounter a new
+ 	source line.
+
+1999-12-17  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-cmd-var.c (mi_cmd_var_list_children): Add test for C++ pseudo
+	variable objects (private, public, protected) as these do not have
+        a type and the -var-list-children operation was dumping core.
+	
+Fri Dec 17 20:23:33 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* gdbmi.texinfo: Document recommended syntax for options.
+
+	* mi-main.c (mi_cmd_data_read_memory): Add support for ``-o
+ 	<offset>''.
+	* gdbmi.texinfo: Document.
+	
+Wed Dec 15 17:43:08 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-getopt.h (mi_getopt): Change optarg to a char pointer. Check
+ 	optind.
+  	* mi-cmd-break.c (mi_cmd_break_insert): Update.
+
+	* mi-main.c (mi_cmd_data_read_memory): Add fields "next-row-addr",
+ 	"prev-row-addr", "next-page-addr", "prev-page-addr" and a per row
+ 	"addr".
+	* gdbmi.texinfo: Update.
+
+Wed Dec 15 01:05:40 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.h (mi_cmd_result): Add MI_CMD_CAUGHT_ERROR for when the
+ 	error is caught.
+
+	* mi-main.c (captured_mi_execute_command): When
+ 	MI_CMD_CAUGHT_ERROR return 0 rethrowing the eror.
+
+1999-12-13  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmd-break.c (mi_cmd_break_insert): Remove unused var.
+
+	* mi-cmd-var.c (mi_cmd_var_update): Remove unused variables.
+
+Mon Dec 13 18:43:36 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-parse.c (mi_parse): Quote the command when printing it.
+	(mi_parse_argv): Fix handling of quoted strings. Was not
+ 	de-quoting them.
+	(mi_parse_argv): Make static.
+
+Mon Dec 13 18:30:03 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.h (mi_cmd_break_insert, mi_cmd_break_watch): Change type
+ 	to mi_cmd_argv_ftype.
+	* mi-cmds.c (mi_cmds): Update.
+	* mi-cmd-break.c (mi_cmd_break_insert, mi_cmd_break_watch): Change
+ 	to new style of arguments with argc and argv.  Parse arguments
+ 	using mi_getopt.
+
+	* mi-cmd-break.c (mi_cmd_break_insert): Wrap body in #ifdef UI_OUT
+ 	to avoid non-ui compile problems.
+
+Mon Dec 13 15:08:36 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-getopt.h, mi-getopt.c: New files. Similar to getopt but with
+ 	well defined semantics.
+	
+Mon Dec 13 14:22:21 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_cmd_break_insert, mi_cmd_break_watch, enum
+ 	wp_type, enum bp_type): Move from here.
+	* mi-cmd-break.c: To here.  New file.
+	(mi_cmd_break_insert, mi_cmd_break_insert, mi_cmd_break_watch):
+ 	Use error to report problems.
+
+1999-12-09  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Update description of exec-interrupt.
+
+	* mi-main.c (mi_cmd_exec_interrupt): If the program is not
+ 	executing, don't try to interrupt it, but error out instead.  Make
+ 	sure previous_async_command is not null before duplicating it into
+ 	last_async_command.
+
+	* gdbmi.texinfo: Add examples for data-evaluate-expression.
+
+1999-12-08  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmd-var.c (mi_cmd_var_assign, mi_cmd_var_create,
+ 	mi_cmd_var_delete, mi_cmd_var_evaluate_expression,
+ 	mi_cmd_var_info_expression, mi_cmd_var_info_num_children,
+ 	mi_cmd_var_info_type, mi_cmd_var_list_children,
+ 	mi_cmd_var_set_format, mi_cmd_var_show_attributes,
+ 	mi_cmd_var_show_format, mi_cmd_var_update): Change to use new
+ 	style of arguments with argc and argv.
+	(next_arg): Delete.
+	(which_var): Delete.
+
+	* mi-cmds.c (mi_cmds): Update entries for mi_cmd_var_assign,
+ 	mi_cmd_var_create, mi_cmd_var_delete,
+ 	mi_cmd_var_evaluate_expression, mi_cmd_var_info_expression,
+ 	mi_cmd_var_info_num_children, mi_cmd_var_info_type,
+ 	mi_cmd_var_list_children, mi_cmd_var_set_format,
+ 	mi_cmd_var_show_attributes, mi_cmd_var_show_format,
+ 	mi_cmd_var_update.
+
+	* mi-cmds.h (mi_cmd_var_assign, mi_cmd_var_create,
+ 	mi_cmd_var_delete, mi_cmd_var_evaluate_expression,
+ 	mi_cmd_var_info_expression, mi_cmd_var_info_num_children,
+ 	mi_cmd_var_info_type, mi_cmd_var_list_children,
+ 	mi_cmd_var_set_format, mi_cmd_var_show_attributes,
+ 	mi_cmd_var_show_format, mi_cmd_var_update): Update declarations.
+
+1999-12-08  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Comment out -data-assign command.  * mi-main.c
+ 	(mi_cmd_data_assign): Do not use, comment out.  * mi-cmds.h
+ 	(mi_cmd_data_assign): Remove.  * mi-cmds.c: Remove -data-assign
+ 	command from MI interface.
+
+1999-12-07  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-parse.c (mi_parse): Add '\n' at end of error messages, so
+ 	that prompt comes out on new line.
+
+	* gdbmi.texinfo: Update disassembly command output.
+
+1999-12-06  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (gdb_do_disassemble): Update output for UI_OUT case.
+
+1999-12-02  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Update exec-until output, including the reason
+ 	for stopping.
+
+Thu Dec  2 17:17:22 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.c: Include <string.h> for memset.
+
+1999-12-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_exec_return): ifdef the references to
+ 	return_command_wrapper().
+	
+1999-12-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_gdb_exit, mi_cmd_exec_interrupt,
+ 	mi_cmd_target_select, mi_execute_async_cli_command,
+ 	mi_exec_async_cli_cmd_continuation, mi_load_progress): Don't print
+ 	last_async_command if it is NULL.
+	(mi_cmd_exec_return): 
+
+1999-12-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_exec_return): Reimplement using
+ 	return_command() instead of mi_execute_async_cli_command().
+
+1999-12-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.h: Export mi_cmd_data_assign and
+ 	mi_cmd_data_evaluate_expression.
+
+	* mi-cmds.c (mi_cmds): Hook data-assign to mi_cmd_data_assign and
+ 	data-evaluate-expression to mi_cmd_data_evaluate_expression.
+
+	* mi-main.c (mi_cmd_data_assign): New function. Implement
+ 	data-assign command.
+	(mi_cmd_data_evaluate_expression): New function. Implement
+ 	data-evaluate-expression command.
+
+1999-12-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Fix some texinfo formatting errors.
+
+1999-12-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Update data-list-register-values description.
+
+	* mi-cmds.h: Export mi_cmd_data_list_register_values.
+
+	* mi-cmds.c (mi_cmds): Hook data-list-register-values to
+ 	mi_cmd_data_list_register_values.
+
+	* mi-main.c (mi_cmd_data_list_register_values): New
+ 	function. Implements the -data-list-register-values command.
+	(get_register): New function. Output the contents of a given
+ 	register.
+
+Wed Dec  1 20:27:22 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_execute_async_cli_command): Append missing "\n"
+ 	for synchronous stopped message.
+
+1999-11-30  James Ingham  <jingham@leda.cygnus.com>
+
+	* gdbmi.texinfo: Fix obvious typo in @end statement.
+
+Wed Dec  1 12:36:27 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmd-var.c: Include "value.h".
+	* mi-console.c: Include <string.h>.
+
+Wed Dec  1 00:21:03 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (captured_mi_execute_command): For a CLI command, pass
+ 	"%s" to mi_execute_cli_command to stop core dumps.
+	(captured_mi_execute_command): Echo CLI commands on gdb_stdlog.
+
+Wed Dec  1 00:10:07 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* gdbmi.texinfo: Explain NR-BYTES and ADDR.
+
+Tue Nov 30 23:31:57 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmd-var.c (mi_cmd_var_create, mi_cmd_var_delete,
+ 	mi_cmd_var_set_format, mi_cmd_var_show_format,
+ 	mi_cmd_var_info_num_children, mi_cmd_var_list_children,
+ 	mi_cmd_var_info_type, mi_cmd_var_info_expression,
+ 	mi_cmd_var_show_attributes, mi_cmd_var_evaluate_expression,
+ 	mi_cmd_var_assign, mi_cmd_var_update, varobj_update_one, next_arg,
+ 	which_var): New file.  Move varobj commands to here from
+ 	mi-main.c.
+
+	* mi-console.h, mi-console.c (mi_console_file_new,
+ 	mi_console_file_delete, mi_console_file_fputs,
+ 	mi_console_raw_packet, mi_console_file_flush): New files. Move
+ 	mi_console_file to here from mi-main.c.
+
+Tue Nov 30 19:37:25 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (captured_mi_execute_command): Use fputstr_unfiltered
+ 	when printing error messages.
+	(mi_cmd_execute): Ditto.
+
+1999-11-29  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Describe -data-list-changed-registers,
+ 	-data-list-register-names. Add examples for
+ 	-exec-next-instruction, exec-step-instruction, -exec-run,
+ 	-exec-until.  Format examples for -data-read-memory.
+	update example for -target-download.
+	
+1999-11-29  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Remove mentioning of inaccurate watchpoint hit
+ 	count.
+	
+Mon Nov 29 19:28:55 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_execute_async_cli_command): Return ``enum
+ 	mi_cmd_cmd_result''.  mi_cmd_exec_run, mi_cmd_exec_next,
+ 	mi_cmd_exec_step, mi_cmd_exec_step_instruction,
+ 	mi_cmd_exec_finish, mi_cmd_exec_until, mi_cmd_exec_return,
+ 	mi_cmd_exec_continue): Update call.
+	(mi_execute_async_cli_command): When target is synchronous, fake
+ 	asynchronous behavour (ulgh).  Allows tests to be run on built-in
+ 	simulator and native targets.
+
+Mon Nov 29 15:15:16 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.h (mi_cmd_gdb_exit), mi-cmds.c (mi_cmds), mi-main.c
+ 	(mi_cmd_gdb_exit): Change function signature to mi_cmd_argv_ftype.
+
+1999-11-28  Andew Cagney  <cagney@rat-in-a-hat.cygnus.com>
+
+	* mi-parse.c: Include <ctype.h> and <string.h>
+
+1999-11-26  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* gdbmi.texinfo: Added watchpoint command descriptions and
+ 	examples.
+
+	* mi-main.c (mi_load_progress): Add parameter for total sent so far.
+	Print it as well.
+	
+Fri Nov 26 10:17:49 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* gdbmi.texinfo (section Output Syntax): For lists, the <string>
+ 	part of a <result> is optional.  Clarify syntax.
+	(appendix Proposed v2.0 Output Syntax): New section. Provide
+ 	record of discussion of possible changes to syntax.
+
+Wed Nov 24 19:41:35 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_cmd_data_read_memory): Simplify.  Fix coredump
+ 	when arguments were bad.
+	(mi_cmd_execute): Change parameter to ``struct mi_parse''.  Handle
+ 	case of argv_func as well as args_func.
+	(captured_mi_execute_command): Update.
+
+	* mi-cmds.c (struct mi_cmd): Add field for mi_cmd_argv_ftype.
+	(mi_cmds): Update mi_cmd_data_read_memory.
+	(mi_lookup): Return 
+
+	* mi-cmds.h (mi_cmd_args_ftype): Rename mi_cmd_ftype. Make all
+ 	functions of type this type.
+	(mi_cmd_argv_ftype): Declare.
+	(mi_cmd_data_read_memory): Change type to mi_cmd_argv_fytpe.
+	(struct mi_cmd): Move declaration to here from mi-cmds.c.
+	(mi_lookup): Return a pointer to ``struct mi_cmd''.
+	
+Wed Nov 24 15:03:34 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-parse.c (mi_parse): Initialize TOKEN when a CLI command.
+
+	* gdbmi.texinfo: Allow a <token> before a CLI command.
+
+	* mi-parse.h (struct mi_parse): Declare.
+	(mi_parse): Change to return a ``struct mi_parse''.
+	(enum mi_command_type): Delete PARSE_ERROR.
+
+	* mi-main.c (struct mi_execute_command_context): Delete.
+	(captured_mi_execute_command): Update
+	(mi_execute_command): Update.  Check for mi_parse returning NULL.
+
+Wed Nov 24 12:57:14 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-parse.h: Remove const, from cmd parameter.  Causes cascading
+ 	warnings.
+
+Wed Nov 24 15:03:34 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-parse.c (mi_parse): New function.  Move parse code to here.
+	* mi-main.c (parse): From here. Delete.
+
+Wed Nov 24 12:57:14 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-parse.c, mi-parse.h: New files. Implement mi_parse_env.
+
+Wed Nov 24 11:24:05 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-out.c (mi_field_string): Make string parameter constant.
+
+1999-11-23  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.h (mi_cmd_target_download): Export. 
+
+	* mi-cmds.c (mi_cmds): Add mi_cmd_target_download.
+
+	* mi-main.c: Include <sys/time.h>.
+	(mi_cmd_target_download): New function, implement the
+ 	target-download command.
+	(mi_load_progress): New function. Called via the
+ 	show_load_progress hook. Prints updates every 0.5 secs.
+	(mi_command_loop): Initialize the show_load_progress hook.
+
+1999-11-22  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_exec_until): New function. Implement until
+ 	command.
+	(mi_cmd_exec_step_instruction): New function. Implement stepi
+ 	command.
+	(mi_cmd_exec_next_instruction): New function. Implement nexti
+ 	command.
+	
+	* mi-cmds.c (mi_cmds): Add mi_cmd_exec_step_instruction,
+ 	mi_cmd_exec_next_instruction, mi_cmd_exec_until.
+
+	* mi-cmds.h (mi_cmd_exec_step_instruction,
+ 	mi_cmd_exec_next_instruction, mi_cmd_exec_until): Export.
+	
+Tue Nov 23 00:30:37 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi/gdbmi.texinfo: Document -data-read-memory.
+	
+	* mi-main.c (mi_cmd_data_read_memory): Fix off-by-one check of
+ 	argc.
+	(mi_cmd_data_read_memory): Label the output table with "memory".
+
+Thu Nov 18 18:15:53 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_cmd_exec_interrupt, mi_cmd_break_insert,
+ 	mi_cmd_break_watch, mi_cmd_disassemble, mi_cmd_execute): Replace
+ 	strdup with xstrdup.
+
+Thu Nov 18 20:50:09 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_cmd_data_read_memory): New function.  Implement
+ 	data-read-memory.
+
+	* mi-cmds.h, mi-cmds.c: Add mi_cmd_data_read_memory.
+	* mi-cmds.c (mi_cmds): Ditto.
+
+1999-11-11  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.h (mi_cmd_break_watch): Export.
+
+	* mi-cmds.c (mi_cmds): Hook up break-watch to function
+ 	mi_cmd_break_watch.
+
+	* mi-main.c (wp_type): New enumeration for the possible types of
+ 	watchpoints.
+	(mi_cmd_break_watch): New function, implements the break-watch
+ 	command.
+
+1999-11-11  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_break_insert): Handle case in which the command is
+	just a -break-insert w/o args.
+
+Fri Nov 12 00:01:52 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-out.c (mi_field_string): Always quote the string.
+
+1999-11-10  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.h(mi_cmd_data_list_changed_registers,
+ 	mi_cmd_data_list_register_names): Export.
+
+	* mi-cmds.c (mi_cmds): Hook up data-list-changed-registers to
+ 	mi_cmd_data_list_changed_registers and data-list-register-names to
+ 	mi_cmd_data_list_register_names.
+
+	* mi-main.c (mi_cmd_data_list_changed_registers): New function,
+ 	implements the data-list-changed-registers command.
+	(mi_cmd_data_list_register_names): New function, implements the
+ 	data-list-register-names command.
+	(register_changed_p): New function. Decide whether the register
+ 	contents have changed.
+	(setup_architecture_data): New function. Initialize registers
+ 	memory.
+	(_initialize_mi_main): Call setup_architecture_data(), and
+ 	register_gdbarch_swap().
+
+Wed Nov 10 18:35:08 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_execute_command): Correctly quote error messages.
+
+Wed Nov 10 11:05:14 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi/gdbmi.texinfo: Delete <stream-output>.  Replaced by
+ 	<c-string>.
+
+	* mi-main.c (mi_console_raw_packet): Always quote console output.
+
+Tue Nov  9 17:53:05 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_console_file_new), mi-out.c (mi_out_new): Replace
+ 	the tui_file with a mem_file. Ya!
+	
+	* mi-out.c (do_write): New function, wrapper to gdb_file_write.
+	(mi_out_put): Pass do_write to gdb_file_put.
+
+	* mi-main.c (mi_console_file_flush): Rewrite.  Use
+ 	mi_console_raw_packet to send data to the console.
+	(mi_console_raw_packet): New function. Correctly
+ 	create quoted C string packets.
+
+1999-11-08  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.c (mi_cmds): Break-insert is now implemented by
+ 	mi_cmd_break_insert.
+	* mi-cmds.h (mi_cmd_break_insert): Export. 
+	* mi-main.c (bp_type): New enumeration.
+	(mi_cmd_break_insert): New function. Implements all flavors of
+ 	breakpoint insertion.
+
+Mon Nov  8 17:49:17 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_console_file_flush): Replace gdb_file_get_strbuf
+ 	with tui_file_get_strbuf.
+
+Fri Nov  5 17:06:07 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_console_file_delete, mi_console_file_fputs,
+ 	mi_console_file_flush): Call internal_error instead of error.
+
+Thu Nov  4 19:53:32 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (captured_mi_execute_command): New function.
+	(mi_execute_command): Rewrite.  Replace SET_TOP_LEVEL() with call
+ 	to captured_mi_execute_command via catch_errors.
+
+Thu Nov  4 20:33:58 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (clean): Delete.
+	(mi_command_loop): Delete extern declaration of
+ 	mi_execute_command.
+
+1999-10-28  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_stack_select_frame): Conditionalize the body
+ 	on UI_OUT, because select_frame_command_wrapper is only defined if
+ 	UI_OUT is.
+	(mi_cmd_exec_interrupt): Conditionalize the body on UI_OUT,
+ 	because interrupt_target_command_wrapper is only defined if UI_OUT is.
+
+	* mi-cmds.c (mi_cmds): Implement command exec-interrupt by
+ 	mi_cmd_exec_interrupt.  
+
+	* mi-main.c (mi_cmd_exec_interrupt): New function. Implements
+ 	exec-interrupt command.
+	(mi_cmd_execute): If the target is running save execution command
+ 	token in previous_async_command. If the command is not 'interrupt' 
+	and the target is running, reject it.
+	(clean): New function. Free the arg and reset it to NULL.
+
+	* mi-cmds.h (mi_cmd_exec_interrupt):Export.
+
+1999-10-28  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.c (mi_cmds): Implement command stack-select-frame by
+ 	mi_cmd_stack_select_frame.  
+
+	* mi-main.c (mi_cmd_stack_select_frame): New function. Implements
+ 	stack-select-frame command.
+
+	* mi-cmds.h (mi_cmd_select_frame):Export.
+
+1999-10-26  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.c (mi_cmds): Implement commands stack-list-locals and
+ 	stack-list-arguments by mi_cmd_stack_list_locals and
+ 	mi_cmd_stack_list_args.
+
+	* mi-main.c (mi_cmd_stack_list_locals): New function. Implements
+ 	stack-list-locals command.
+	(mi_cmd_stack_list_args): New function. Implements
+ 	stack-list-arguments command.
+	(list_args_or_locals): New function. Do all the work for the
+	listing of locals or arguments.
+
+	* mi-cmds.h (mi_cmd_stack_list_args,mi_cmd_stack_list_locals) :
+ 	Export.
+
+1999-10-25  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-cmds.c (mi_cmds): Add new command stack-info-depth.
+
+	* mi-main.c (mi_cmd_stack_info_depth): New function. Implements
+ 	the stack-info-depth command.
+	* mi-cmds.h (mi_cmd_stack_info_depth): Export.
+
+
+1999-10-22  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_execute_command): Handle MI_CMD_ERROR case
+ 	properly, for command that return error code and don't set
+ 	mi_error_message.
+
+	* mi-cmds.c (mi_cmds): Hook stack-list-frames command to
+ 	mi_cmd_stack_list_frames function.
+	* mi-cmds.h (mi_cmd_stack_list_frames): Export.
+	
+	* mi-main.c (mi_execute_command): Deal with a return code of
+ 	MI_CMD_ERROR from the execution of mi commands.
+	(mi_error_message): Static string variable, to contain the error
+ 	message from mi commands.
+	(mi_cmd_stack_list_frames): New function. Prints a backtrace.
+
+1999-10-18  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_disassemble): Handle the new command line
+ 	parameter that specifies the number of disassembly lines to be
+ 	displayed.
+	(gdb_do_disassemble): Add new parameter. Count the number of lines
+ 	that have been displayed, and stop when limit is reached.
+
+Wed Oct 13 18:04:13 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_command_loop): Don't initialize ``flush_hook''.
+
+1999-10-13  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi/gdbmi.texinfo: More reformatting of the grammars.
+
+1999-10-12  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi/gdbmi.texinfo: More TeX formatting.
+
+1999-10-11  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi/gdbmi.texinfo: First pass completed. All commands should have
+	some comments/info.
+	Escape '@' output special char.
+	Reformat for TeX.
+
+1999-10-08  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi/gdbmi.texinfo: Filled in part of file command section, and
+ 	stack section.
+
+1999-10-07  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi/gdbmi.texinfo: Filled in some sections about execution
+ 	commands.
+
+Tue Oct  5 15:27:28 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.h: Sort table
+	* mi-cmds.c: Ditto.
+	(MI_TABLE_SIZE): Increase to 251.
+
+1999-10-04  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_cmd_var_create, mi_cmd_var_delete): Add missing
+	cleanups.
+	
+1999-10-04  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (next_arg): Returns lenght as well.
+	(which_var, mi_cmd_var_create, mi_cmd_var_delete,
+	mi_cmd_var_set_format, mi_cmd_var_update): Do not modify the input
+	string, use allocated storage instead.
+	(mi_cmd_var_assign): Adjust call to next_arg() to include new
+	argument.
+
+1999-10-04  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_execute_command): Fix handling of errors.
+
+1999-10-04  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-out.c (mi_out_new): Call tui_sfileopen() instead of
+        deprecated gdb_file_init_astream().
+	* mi-main.c (mi_console_file_new): Ditto.
+
+Mon Oct  4 15:17:29 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.h: Sort function declarations.
+ 	(mi_lookup): Add extern.
+
+	* mi-cmds.c (mi_lookup): Delete dead code.
+	(build_table): Call  internal_error instead of error.
+	(build_table): Send trace output to gdb_stdlog.
+
+1999-10-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_execute_async_cli_command): Don't do the cleanups
+ 	if target_executing is null.
+
+1999-09-28  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (async_p): Change var name to event_loop_p.
+
+Mon Sep 27 15:11:00 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_execute_async_cli_command, mi_execute_command):
+ 	Replace target_has_async with function target_can_async_p.
+
+Sun Sep 26 00:12:52 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_cmd_target_select_continuation): Delete function.
+	(mi_cmd_target_select): Simplify.  target-connect is guarenteed to
+ 	be synchronous.
+
+Sun Sep 26 00:12:52 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.h (mi_cmd_ftype): Replace mi_impl_ftype.
+	(enum mi_cmd_result): Define.
+	* mi-cmds.c (struct mi_cmd): Update.
+	(mi_lookup): Update.
+	* mi-main.c (mi_cmd_execute): Update.
+
+	* mi-main.c (mi_cmd_gdb_exit, mi_cmd_exec_run, mi_cmd_exec_next,
+ 	mi_cmd_exec_step, mi_cmd_target_select, mi_cmd_exec_continue,
+ 	mi_cmd_exec_return, mi_cmd_exec_finish, mi_cmd_disassemble,
+ 	mi_cmd_var_create, mi_cmd_var_delete, mi_cmd_var_set_format,
+ 	mi_cmd_var_show_format, mi_cmd_var_info_num_children,
+ 	mi_cmd_var_list_children, mi_cmd_var_info_type,
+ 	mi_cmd_var_info_expression, mi_cmd_var_show_attributes,
+ 	mi_cmd_var_evaluate_expression, mi_cmd_var_update): Update.
+  	Return MI_CMD_DONE.
+
+1999-09-22  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_cmd_var_create): Use paddr() to format address
+	on trace output.
+
+1999-09-21  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_cmd_var_create): Test for varobjdebug before
+	printing trace and send it to gdb_stdlog.
+
+Mon Sep 20 13:41:04 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* Makefile.in (mi-out.o): Add dependency list.
+	* mi-out.c: Include "mi-out.h".
+
+1999-09-18  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (_initialize_mi_main): Events on stadin are now
+ 	handled by stdin_event_handler.
+
+1999-09-17  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-cmds.c (mi_cmds): Add var-* commands.
+
+1999-09-17  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_cmd_var_create, mi_cmd_var_delete,
+	mi_cmd_var_set_format, mi_cmd_var_show_format,
+	mi_cmd_var_info_num_children, mi_cmd_var_list_children,
+	mi_cmd_var_info_type, mi_cmd_var_info_expression,
+	mi_cmd_var_show_attributes, mi_cmd_var_evaluate_expression,
+	mi_cmd_var_assign, mi_cmd_var_update, varobj_update_one,
+	which_var, next_arg): New functions.  Implement the -var-*
+	commands.
+	* mi-cmds.h: Add prototypes for the above.
+
+1999-09-14  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-cmds.c (mi_cmds): Add detach command.
+
+1999-09-09  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-cmds.c (lookup_table): Fix typo.
+
+1999-09-09  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-cmds.c (mi_cmds): Fix typo and missing command.
+
+1999-09-09  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c: Properly align function prototypes.
+	(mi_cmd_target_select): Proper check for NULL value.
+
+1999-09-09  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_execute_async_cli_command): Fix for native targets
+	that do not have async yet.
+
+1999-09-01  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_disassemble): Remove unused var.
+	(gdb_do_disassemble): Ditto.
+
+1999-08-30  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c: Replace all the occurrences of 'asynch' in variable
+ 	or function names with 'async' to make it consistent with the rest
+ 	of gdb.
+
+Mon Aug 30 18:16:39 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c: #include <ctype.h> for isspace().
+
+1999-08-27  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (gdb_do_disassemble): This function returns void, not
+ 	int.
+
+1999-08-26  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_disassemble): Don't use atoi() on the high
+ 	address string, just treat it same as address low.
+	(gdb_do_disassemble): Parse high_address string before seeing if
+ 	it is zero.
+
+1999-08-25  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_disassemble): New function to produce
+ 	disassembly output for mi.
+	(gdb_dis_asm_read_memory): New function. Read the disassembly from
+ 	the executable file, instead of target memory.
+	(compare_lines): New function. Compare order of disassembly lines.
+	(gdb_do_disassemble): New function. Do the real job of getting the
+ 	assembly code out.
+
+	* mi-cmds.c (mi_cmds): Do data-disassemble mi command via the
+ 	mi_cmd_disassemble function.
+
+	* mi-cmds.h: Export new function mi_cmd_disassemble.
+
+Wed Aug 25 15:58:31 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_command_loop): Remove references to ui-hooks.
+
+1999-08-21  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_execute_asynch_cli_command): Fix the incorrect
+	usage of strcat(): allocate enough space for the string.
+
+1999-08-13  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	From Christopher Faylor <cgf@cygnus.com>
+	* mi-main.c (mi_execute_command): Make sure we flush all the
+ 	output after each command.
+
+1999-08-10  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (_initialize_mi_main): Remove casting in call to
+ 	add_file_handler.
+
+Sun Aug  8 17:20:57 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_cmd_target_select, mi_execute_asynch_cli_command):
+ 	Replace call to fatal with call to internal_error.
+
+1999-07-26  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_cmd_execute): Add return code.
+	(mi_execute_command): Make appropriate changes when calling the
+	function mentioned above.
+	(mi_cmd_gdb_exit, mi_cmd_target_select,
+	mi_cmd_target_select_continuation, mi_execute_command,
+	mi_exec_asynch_cli_cmd, mi_exec_asynch_cli_cmd_continuation):
+	Print token, prefix, class and output (if any) in one single group
+	of statements.
+	(mi_execute_command, mi_cmd_execute): Fix error prefix.
+	(mi_cmd_execute): Use exec cleanup for token.
+	* mi-out.c (mi_out_rewind): New function.
+	* mi-out.h: Prototype for the above.
+
+1999-07-16  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_cmd_gdb_exit): Use buffer for exit message.
+	(mi_cmd_execute): Route error messages to correct file.
+	(mi_execute_asynch_cli_command): Insert line feed after running
+	message.
+
+1999-07-16  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-out.h (mi_out_buffered): Add extern declaration.
+	* mi-out.c (mi_out_buffered): New function. Insert a string at the
+	current buffer position.
+	* mi-main.c (mi_cmd_target_select, mi_execute_command,
+	mi_cmd_execute, mi_execute_asynch_cli_command): Use the above
+	function instead of printing to raw_stdout.
+	(mi_cmd_target_select, mi_cmd_target_select_continuation,
+	mi_execute_command, mi_cmd_execute, mi_execute_cli_command,
+	mi_exec_asynch_cli_cmd_continuation): Fix handling of token and
+	prefix.
+	(mi_execute_cli_command): Remove parameter no longer needed.
+
+1999-07-15  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c (mi_cmd_target_select_continuation): Print the numeric
+ 	token when we are connected.
+	(mi_execute_command): Don't print the token now, do it later.
+	(mi_execute_cli_command): Add a new parameter for the numeric
+ 	token.  Print the token, the prefix and the class after the
+ 	command has executed, not before.
+	(mi_execute_asynch_cli_command): Don't print an extra blank line.
+
+1999-07-15  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_gdb_exit): Add \n at the end.
+
+1999-07-15  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_cmd_execute): New function. Dispatch a mi operation.
+	(mi_execute_command): Use the above.
+
+1999-07-15  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c: Fix identation.
+
+1999-07-15  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* mi-main.c: Include target.h and inferior.h.
+	(mi_cmd_target_select): New function to execute the target-select
+ 	mi operation.
+	(mi_cmd_target_select_continuation): New function. Continuation
+ 	for the target-select operation.
+	(mi_execute_command): In case of an MI command which requires
+ 	asynchronous execution, do not try to display the result now. If
+ 	the execution has to look synchronous don't display the "(gdb)"
+ 	prompt.
+	(mi_execute_asynch_cli_command): Invoke real asynchronous
+ 	commands, set up exec_cleanups, and continuations.
+	(mi_exec_asynch_cli_cmd_continuation): New function. Continuation
+ 	for all the MI execution commands except 'target-select'.
+	(mi_execute_command): Handle null commands by exiting gdb, instead
+ 	of core dumping.
+
+	* mi-cmds.c (mi_cmds): Hook up -target-select operation to new mi
+ 	function.
+
+	* mi-cmds.h (mi_cmd_target_select): Add extern declaration.
+
+Thu Jul 15 10:31:39 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (struct mi_console_file): Add field ``prefix''.
+	(mi_console_file_new): Add argument prefix.  Initialize prefix
+ 	field.
+	(mi_console_file_flush): Use ``prefix'' instead of "~" as the
+ 	prefix string.
+	(mi_command_loop): Update stream output prefixes. gdb_stdout ==
+ 	"~", gdb_stderr / gdb_stdlog == "&", gdb_stdtarg == "@".
+
+1999-07-13  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (ui_out_data): New field first_header. Fix output when
+	no breakpoints are found.
+	(mi_table_begin, mi_table_body, mi_table_header): Test for
+	first_header.
+	(mi_table_end): Test for supress_field_separator.
+	(mi_message): Remove messages from MI output.
+
+1999-06-30  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-cmds.c (mi_cmds[]): Delete gdb-cli operation.
+	* mi-main.c (parse): Remove ifdefs for cli commands parsing.
+	(mi-execute-command): Ditto.
+
+Mon Jun 28 13:06:52 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-out.h: New file.
+	(mi_out_new, mi_out_put): Move mi specific delcarations to here.
+	* ui-out.h: From here.
+
+	* mi-main.c: Include "mi-out.h".
+
+1999-06-25  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* top.c (print_gdb_version): Add the word HEADLESS when output
+	follows headless format.
+	(print_command_lines): Fix typo.
+
+1999-06-25  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* event-loop.h: Export input_fd.  
+	* mi-main.c (mi_command_loop): Use the event loop if running
+ 	asynchronously.
+	(mi_execute_command_wrapper): New function.
+	(_initialize_mi-main): Set things up for running asynchronously.
+
+1999-06-18  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+        * mi-cmds.c (mi_lookup): Deleted.
+        (lookup_table): New function. Replaces old mi_lookup() for local
+        use.
+        (mi_lookup): New function. External interface for command table
+        searchs.
+        (build_table): New definition.
+        (mi_cmds[]): Add several command implementations and the gdb-cli
+        special operation.
+        (mi_cmd_execute): Deleted.
+        * mi-cmds.h: Add type definition for command implementation
+        function pointers, add declaration for new implementation
+        functions and a declaration for mi_lookup().
+        * mi-main.c (mi_execute_asynch_cli_command): New
+        function. Captures code that was repeated for all asynch
+        operations.
+        (mi_cmd_exec_*): Use the above new function.
+        (mi_gdb_cmd_exit): Fix the output, printing something appropriate.
+        (mi_cmd_exec_finish): New operation implementation function.
+        (mi_cmd_exec_return): Ditto.
+        (parse): Prepare to remove cli commands.
+        (mi_execute_command): Fix the output and change the way mi-cmds is
+        used.
+
+1999-06-18  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+        * mi-out.c (mi_table_begin): Add missing field separator call.
+
+Thu Jun 17 21:05:40 1999  Fernando Nasser  <fnasser@tofu.to.cygnus.com>
+
+	* breakpoint.c (breakpoint_1): Remove space in breakpoint table
+	id.
+	(mention): Use ui_out for last new line (forgotten).
+
+1999-06-16  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c (mi_console_file_flush): Prevent prefix printing when
+	buffer empty; change prefix to '~'.
+	(mi_cmd_exec_*): Prefix normal output with '^' instead of
+	','; remove unwanted new lines before "stopped".
+
+1999-06-16  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-cmds.c (struct mi_cmds): Updated entries for -exec-continue
+	and exec-next operations.
+	(mi_cmd_execute): New text for error messages.
+	* mi-cmds.h: Add declaration for mi_cmd_exec_next and
+	mi_cmd_exec_continue.
+	* mi-main.c (mi_cmd_exec_next): New function. Implements exec-next
+	operation.
+	(mi_cmd_exec_continue): New function. Implements exec-continue
+	operation.
+	(mi_execute_comand): Add missing space to prompt.
+	(mi_cmd_exec_run): Ditto.
+	(mi_cmd_exec_step): Ditto.
+	* mi-out.c (mi_out_new): Add flags argument to ui_out_new call.
+	(ui_list_end): Reset supress_field_separator flag.
+
+Sat Jun 12 11:49:10 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.h. mi-cmds.c (exec step): Command implemented by
+ 	mi_cmd_exec_step instead of cli call.
+	* mi-main.c (mi_cmd_exec_step): New function.
+
+	* mi-cmds.h. mi-cmds.c (exec run): Command implemented by
+ 	mi_cmd_exec_run instead of cli call.
+	* mi-main.c (mi_cmd_exec_run): New function.
+
+	* mi-cmds.h. mi-cmds.c (gdb exit): Command implemented by
+ 	mi_cmd_gdb_exit instead of quit_force.
+	* mi-main.c (mi_cmd_gdb_exit): New function.
+
+Sat Jun 12 11:33:23 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_command_loop): Pass mi_input to
+ 	simplified_command_loop.
+	(mi_input): New function.  Calls gdb_readline with no prompt.
+
+Sat Jun 12 11:19:02 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_console_file_fputs): Re-implement.  Use a buffer
+ 	to accumulate output.
+
+	* mi-main.c (struct mi_console_file): Add a buffer.
+	(mi_console_file_new): Create a buffer.
+	(mi_console_file_flush): New function.
+
+Sat Jun 12 10:59:39 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-cmds.h (raw_stdout): Declare.  Will be moved later.
+	* mi-cmds.c (mi_cmd_execute): Send error messages to RAW stdout.
+	(mi_cmds): Sort by class.
+
+	* mi-main.c (raw_stdout): Make global.
+	* mi-main.c: Remove #ifdef UI_OUT.  File assumes UI_OUT is
+ 	present.
+	* mi-main.c: Include "gdb_string.h".
+	(mi_out_put): Delete declaration.
+
+1999-06-11  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-main.c: Add pre-processor test for UI_OUT.
+	(mi_execute_command): Add pre-processor test for UI_OUT.
+
+Fri Jun 11 23:11:41 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (raw_stdout): New variable.
+	(mi_execute_command): Write mi-out direct to raw_stdout.
+	(mi_command_loop): Create raw_stdout. Attach gdb_stdout to the
+ 	console.
+	(mi_console_file_fputs, mi_console_file_delete,
+ 	mi_console_file_new): New functions.
+	(struct mi_console_file): Declare.
+
+Fri Jun 11 18:34:33 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c (mi_execute_command): Call mi_out_put to display the
+ 	result.
+	* mi-out.c (mi_out_put): New function.
+	* ui-out.h (mi_out_put): Add declare.  Will move later.
+	* Makefile.in (mi-cmds.o, mi-main.o): Add dependency on ui-out.h.
+
+	* mi-out.c (mi_field_string, mi_field_fmt, mi_message, mi_flush,
+ 	out_field_fmt, list_open, list_close): Replace gdb_stdout with
+ 	data->buffer.
+	(field_separator, list_open, list_close): Add uiout parameter.
+	(mi_table_begin, mi_table_body, mi_table_end, mi_list_begin,
+ 	mi_list_end, mi_field_string, mi_field_fmt, out_field_fmt,
+ 	out_field_fmt): Update.
+
+	* mi-out.c (mi_out_new): Initialize supress_field_separator.
+	(supress_field_separator): Move into mi-out local data object.
+	(mi_table_begin, mi_list_begin, field_separator): Update.
+
+Fri Jun 11 16:08:37 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-out.c (mi_out_new): New function, replace init_mi_out.
+	* mi-main.c (mi_command_loop): Call mi_out_new().
+
+	* ui-out.h (mi_out_new): Add declaration.  Will move later.
+	(mi_ui_out_impl): Delete.
+
+Wed Jun  9 16:42:16 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* mi-main.c: Include "ui-hooks.h".
+ 	(mi_init_ui, mi_command_loop): New functions.
+	(_initialize_mi_main): Install ``mi'' as the interpreter when
+ 	selected.
+
+Mon Jun  7 18:43:43 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	From Fernando Nasser  <fnasser@totem.to.cygnus.com>
+	* mi-cmds.c (build_table): Clean up error message.
+	* mi-cmds.c (mi_cmd_execute), mi-main.c (mi_execute_command): Only
+ 	print debug information when mi_debug_p.
+	* mi-cmds.h (mi_debug_p), mi-main.c: Global, control debug messages.
+	
+Thu Jun  3 00:44:52 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+  	From Fernando Nasser  <fnasser@totem.to.cygnus.com>:
+	* mi-cmds.c: Add CLI definitions for "exec-arguments",
+ 	"exec-next", "gdb-exit", "break-list", "break-info", "exec-step"
+ 	and "stack-list-frames" to mi_cmds.
+	(struct mi_command): Add ``from_tty'' argument to func.
+	* mi-cmds.h (quit_force): Declare.
+
+1999-05-31  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-out.c (mi_table_end): Remove unwanted "\n".
+
+Thu May 27 14:59:06 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* top.c: Include "ui-hooks.h".
+	(call_interp_loop): Tempoary.  Pass mi_execute_command to
+ 	simplified_command_loop.  Initialize gdb_stdout & gdb_stderr to
+ 	stdio gdb_file streams.  Force all hooks to null.
+
+	* mi-cmds.h, mi-main.c, mi-cmds.c: New files.
+	* Makefile.in (SFILES): Add mi-main.c, mi-cmds.c
+	(COMMON_OBS): Add mi-main.o, mi-cmds.o.
+	(mi_cmds_h): Define.
+
+Wed May 26 12:39:49 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* top.c (call_interp_loop): Hack.  Add extern declaration for
+ 	mi_ui_out_impl.
+
+1999-05-25  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-out.c: New table syntax.
+
+Mon May 24 16:16:29 1999  Andrew Cagney  <cagney@amy.cygnus.com>
+
+	mi-out.c (_initialize_mi_out): Add external declaration.
+
+1999-05-21  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-out.c (mi_table_begin): Added missing parameter.
+
+1999-05-21  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-out.c: Changed table markers and added table id.
+
+1999-05-21  Fernando Nasser  <fnasser@totem.to.cygnus.com>
+
+	* mi-out.c: New file. Implements low-level ui-out primitives for
+	CLI-based interaction.
+
+
+Local Variables:
+mode: change-log
+left-margin: 8
+fill-column: 74
+version-control: never
+End:
diff --git a/gdb/mi/mi-cmd-stack.c b/gdb/mi/mi-cmd-stack.c
new file mode 100644
index 0000000..b4bae47
--- /dev/null
+++ b/gdb/mi/mi-cmd-stack.c
@@ -0,0 +1,309 @@
+/* MI Command Set - stack commands.
+   Copyright 2000, 2002 Free Software Foundation, Inc.
+   Contributed by Cygnus Solutions (a Red Hat company).
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "target.h"
+#include "frame.h"
+#include "value.h"
+#include "mi-cmds.h"
+#include "ui-out.h"
+#include "symtab.h"
+
+/* FIXME: these should go in some .h file but stack.c doesn't have a
+   corresponding .h file. These wrappers will be obsolete anyway, once
+   we pull the plug on the sanitization. */
+extern void select_frame_command_wrapper (char *, int);
+
+static void list_args_or_locals (int locals, int values, struct frame_info *fi);
+
+/* Print a list of the stack frames. Args can be none, in which case
+   we want to print the whole backtrace, or a pair of numbers
+   specifying the frame numbers at which to start and stop the
+   display. If the two numbers are equal, a single frame will be
+   displayed. */
+enum mi_cmd_result
+mi_cmd_stack_list_frames (char *command, char **argv, int argc)
+{
+  int frame_low;
+  int frame_high;
+  int i;
+  struct frame_info *fi;
+
+  if (!target_has_stack)
+    error ("mi_cmd_stack_list_frames: No stack.");
+
+  if (argc > 2 || argc == 1)
+    error ("mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]");
+
+  if (argc == 2)
+    {
+      frame_low = atoi (argv[0]);
+      frame_high = atoi (argv[1]);
+    }
+  else
+    {
+      /* Called with no arguments, it means we want the whole
+         backtrace. */
+      frame_low = -1;
+      frame_high = -1;
+    }
+
+  /* Let's position fi on the frame at which to start the
+     display. Could be the innermost frame if the whole stack needs
+     displaying, or if frame_low is 0. */
+  for (i = 0, fi = get_current_frame ();
+       fi && i < frame_low;
+       i++, fi = get_prev_frame (fi));
+
+  if (fi == NULL)
+    error ("mi_cmd_stack_list_frames: Not enough frames in stack.");
+
+  ui_out_list_begin (uiout, "stack");
+
+  /* Now let;s print the frames up to frame_high, or until there are
+     frames in the stack. */
+  for (;
+       fi && (i <= frame_high || frame_high == -1);
+       i++, fi = get_prev_frame (fi))
+    {
+      QUIT;
+      /* level == i: always print the level 'i'
+         source == LOC_AND_ADDRESS: print the location and the address 
+         always, even for level 0.
+         args == 0: don't print the arguments. */
+      print_frame_info (fi /* frame info */ ,
+			i /* level */ ,
+			LOC_AND_ADDRESS /* source */ ,
+			0 /* args */ );
+    }
+
+  ui_out_list_end (uiout);
+  if (i < frame_high)
+    error ("mi_cmd_stack_list_frames: Not enough frames in stack.");
+
+  return MI_CMD_DONE;
+}
+
+enum mi_cmd_result
+mi_cmd_stack_info_depth (char *command, char **argv, int argc)
+{
+  int frame_high;
+  int i;
+  struct frame_info *fi;
+
+  if (!target_has_stack)
+    error ("mi_cmd_stack_info_depth: No stack.");
+
+  if (argc > 1)
+    error ("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]");
+
+  if (argc == 1)
+    frame_high = atoi (argv[0]);
+  else
+    /* Called with no arguments, it means we want the real depth of
+       the stack. */
+    frame_high = -1;
+
+  for (i = 0, fi = get_current_frame ();
+       fi && (i < frame_high || frame_high == -1);
+       i++, fi = get_prev_frame (fi))
+    QUIT;
+
+  ui_out_field_int (uiout, "depth", i);
+
+  return MI_CMD_DONE;
+}
+
+/* Print a list of the locals for the current frame. With argument of
+   0, print only the names, with argument of 1 print also the
+   values. */
+enum mi_cmd_result
+mi_cmd_stack_list_locals (char *command, char **argv, int argc)
+{
+  if (argc != 1)
+    error ("mi_cmd_stack_list_locals: Usage: PRINT_VALUES");
+
+  list_args_or_locals (1, atoi (argv[0]), selected_frame);
+  return MI_CMD_DONE;
+}
+
+/* Print a list of the arguments for the current frame. With argument
+   of 0, print only the names, with argument of 1 print also the
+   values. */
+enum mi_cmd_result
+mi_cmd_stack_list_args (char *command, char **argv, int argc)
+{
+  int frame_low;
+  int frame_high;
+  int i;
+  struct frame_info *fi;
+
+  if (argc < 1 || argc > 3 || argc == 2)
+    error ("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]");
+
+  if (argc == 3)
+    {
+      frame_low = atoi (argv[1]);
+      frame_high = atoi (argv[2]);
+    }
+  else
+    {
+      /* Called with no arguments, it means we want args for the whole
+         backtrace. */
+      frame_low = -1;
+      frame_high = -1;
+    }
+
+  /* Let's position fi on the frame at which to start the
+     display. Could be the innermost frame if the whole stack needs
+     displaying, or if frame_low is 0. */
+  for (i = 0, fi = get_current_frame ();
+       fi && i < frame_low;
+       i++, fi = get_prev_frame (fi));
+
+  if (fi == NULL)
+    error ("mi_cmd_stack_list_args: Not enough frames in stack.");
+
+  ui_out_list_begin (uiout, "stack-args");
+
+  /* Now let's print the frames up to frame_high, or until there are
+     frames in the stack. */
+  for (;
+       fi && (i <= frame_high || frame_high == -1);
+       i++, fi = get_prev_frame (fi))
+    {
+      QUIT;
+      ui_out_tuple_begin (uiout, "frame");
+      ui_out_field_int (uiout, "level", i);
+      list_args_or_locals (0, atoi (argv[0]), fi);
+      ui_out_tuple_end (uiout);
+    }
+
+  ui_out_list_end (uiout);
+  if (i < frame_high)
+    error ("mi_cmd_stack_list_args: Not enough frames in stack.");
+
+  return MI_CMD_DONE;
+}
+
+/* Print a list of the locals or the arguments for the currently
+   selected frame.  If the argument passed is 0, printonly the names
+   of the variables, if an argument of 1 is passed, print the values
+   as well. */
+static void
+list_args_or_locals (int locals, int values, struct frame_info *fi)
+{
+  struct block *block;
+  struct symbol *sym;
+  int i, nsyms;
+  static struct ui_stream *stb = NULL;
+
+  stb = ui_out_stream_new (uiout);
+
+  block = get_frame_block (fi, 0);
+
+  ui_out_list_begin (uiout, locals ? "locals" : "args");
+
+  while (block != 0)
+    {
+      ALL_BLOCK_SYMBOLS (block, i, sym)
+	{
+          int print_me = 0;
+
+	  switch (SYMBOL_CLASS (sym))
+	    {
+	    default:
+	    case LOC_UNDEF:	/* catches errors        */
+	    case LOC_CONST:	/* constant              */
+	    case LOC_TYPEDEF:	/* local typedef         */
+	    case LOC_LABEL:	/* local label           */
+	    case LOC_BLOCK:	/* local function        */
+	    case LOC_CONST_BYTES:	/* loc. byte seq.        */
+	    case LOC_UNRESOLVED:	/* unresolved static     */
+	    case LOC_OPTIMIZED_OUT:	/* optimized out         */
+	      print_me = 0;
+	      break;
+
+	    case LOC_ARG:	/* argument              */
+	    case LOC_REF_ARG:	/* reference arg         */
+	    case LOC_REGPARM:	/* register arg          */
+	    case LOC_REGPARM_ADDR:	/* indirect register arg */
+	    case LOC_LOCAL_ARG:	/* stack arg             */
+	    case LOC_BASEREG_ARG:	/* basereg arg           */
+	      if (!locals)
+		print_me = 1;
+	      break;
+
+	    case LOC_LOCAL:	/* stack local           */
+	    case LOC_BASEREG:	/* basereg local         */
+	    case LOC_STATIC:	/* static                */
+	    case LOC_REGISTER:	/* register              */
+	      if (locals)
+		print_me = 1;
+	      break;
+	    }
+	  if (print_me)
+	    {
+	      if (values)
+		ui_out_tuple_begin (uiout, NULL);
+	      ui_out_field_string (uiout, "name", SYMBOL_NAME (sym));
+
+	      if (values)
+		{
+		  struct symbol *sym2;
+		  if (!locals)
+		    sym2 = lookup_symbol (SYMBOL_NAME (sym),
+					  block, VAR_NAMESPACE,
+					  (int *) NULL,
+					  (struct symtab **) NULL);
+		  else
+		    sym2 = sym;
+		  print_variable_value (sym2, fi, stb->stream);
+		  ui_out_field_stream (uiout, "value", stb);
+		  ui_out_tuple_end (uiout);
+		}
+	    }
+	}
+      if (BLOCK_FUNCTION (block))
+	break;
+      else
+	block = BLOCK_SUPERBLOCK (block);
+    }
+  ui_out_list_end (uiout);
+  ui_out_stream_delete (stb);
+}
+
+enum mi_cmd_result
+mi_cmd_stack_select_frame (char *command, char **argv, int argc)
+{
+  if (!target_has_stack)
+    error ("mi_cmd_stack_select_frame: No stack.");
+
+  if (argc > 1)
+    error ("mi_cmd_stack_select_frame: Usage: [FRAME_SPEC]");
+
+  /* with no args, don't change frame */
+  if (argc == 0)
+    select_frame_command_wrapper (0, 1 /* not used */ );
+  else
+    select_frame_command_wrapper (argv[0], 1 /* not used */ );
+  return MI_CMD_DONE;
+}
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
new file mode 100644
index 0000000..9c5e49f
--- /dev/null
+++ b/gdb/objfiles.c
@@ -0,0 +1,1011 @@
+/* GDB routines for manipulating objfiles.
+
+   Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+   2001, 2002 Free Software Foundation, Inc.
+
+   Contributed by Cygnus Support, using pieces from other GDB modules.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* This file contains support routines for creating, manipulating, and
+   destroying objfile structures. */
+
+#include "defs.h"
+#include "bfd.h"		/* Binary File Description */
+#include "symtab.h"
+#include "symfile.h"
+#include "objfiles.h"
+#include "gdb-stabs.h"
+#include "target.h"
+#include "bcache.h"
+
+#include <sys/types.h>
+#include "gdb_stat.h"
+#include <fcntl.h>
+#include "gdb_obstack.h"
+#include "gdb_string.h"
+
+#include "breakpoint.h"
+
+/* Prototypes for local functions */
+
+#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
+
+#include "mmalloc.h"
+
+static int open_existing_mapped_file (char *, long, int);
+
+static int open_mapped_file (char *filename, long mtime, int flags);
+
+static PTR map_to_file (int);
+
+#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
+
+static void add_to_objfile_sections (bfd *, sec_ptr, PTR);
+
+/* Externally visible variables that are owned by this module.
+   See declarations in objfile.h for more info. */
+
+struct objfile *object_files;	/* Linked list of all objfiles */
+struct objfile *current_objfile;	/* For symbol file being read in */
+struct objfile *symfile_objfile;	/* Main symbol table loaded from */
+struct objfile *rt_common_objfile;	/* For runtime common symbols */
+
+int mapped_symbol_files;	/* Try to use mapped symbol files */
+
+/* Locate all mappable sections of a BFD file. 
+   objfile_p_char is a char * to get it through
+   bfd_map_over_sections; we cast it back to its proper type.  */
+
+#ifndef TARGET_KEEP_SECTION
+#define TARGET_KEEP_SECTION(ASECT)	0
+#endif
+
+/* Called via bfd_map_over_sections to build up the section table that
+   the objfile references.  The objfile contains pointers to the start
+   of the table (objfile->sections) and to the first location after
+   the end of the table (objfile->sections_end). */
+
+static void
+add_to_objfile_sections (bfd *abfd, sec_ptr asect, PTR objfile_p_char)
+{
+  struct objfile *objfile = (struct objfile *) objfile_p_char;
+  struct obj_section section;
+  flagword aflag;
+
+  aflag = bfd_get_section_flags (abfd, asect);
+
+  if (!(aflag & SEC_ALLOC) && !(TARGET_KEEP_SECTION (asect)))
+    return;
+
+  if (0 == bfd_section_size (abfd, asect))
+    return;
+  section.offset = 0;
+  section.objfile = objfile;
+  section.the_bfd_section = asect;
+  section.ovly_mapped = 0;
+  section.addr = bfd_section_vma (abfd, asect);
+  section.endaddr = section.addr + bfd_section_size (abfd, asect);
+  obstack_grow (&objfile->psymbol_obstack, (char *) &section, sizeof (section));
+  objfile->sections_end = (struct obj_section *) (((unsigned long) objfile->sections_end) + 1);
+}
+
+/* Builds a section table for OBJFILE.
+   Returns 0 if OK, 1 on error (in which case bfd_error contains the
+   error).
+
+   Note that while we are building the table, which goes into the
+   psymbol obstack, we hijack the sections_end pointer to instead hold
+   a count of the number of sections.  When bfd_map_over_sections
+   returns, this count is used to compute the pointer to the end of
+   the sections table, which then overwrites the count.
+
+   Also note that the OFFSET and OVLY_MAPPED in each table entry
+   are initialized to zero.
+
+   Also note that if anything else writes to the psymbol obstack while
+   we are building the table, we're pretty much hosed. */
+
+int
+build_objfile_section_table (struct objfile *objfile)
+{
+  /* objfile->sections can be already set when reading a mapped symbol
+     file.  I believe that we do need to rebuild the section table in
+     this case (we rebuild other things derived from the bfd), but we
+     can't free the old one (it's in the psymbol_obstack).  So we just
+     waste some memory.  */
+
+  objfile->sections_end = 0;
+  bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *) objfile);
+  objfile->sections = (struct obj_section *)
+    obstack_finish (&objfile->psymbol_obstack);
+  objfile->sections_end = objfile->sections + (unsigned long) objfile->sections_end;
+  return (0);
+}
+
+/* Given a pointer to an initialized bfd (ABFD) and some flag bits
+   allocate a new objfile struct, fill it in as best we can, link it
+   into the list of all known objfiles, and return a pointer to the
+   new objfile struct.
+
+   The FLAGS word contains various bits (OBJF_*) that can be taken as
+   requests for specific operations, like trying to open a mapped
+   version of the objfile (OBJF_MAPPED).  Other bits like
+   OBJF_SHARED are simply copied through to the new objfile flags
+   member. */
+
+struct objfile *
+allocate_objfile (bfd *abfd, int flags)
+{
+  struct objfile *objfile = NULL;
+  struct objfile *last_one = NULL;
+
+  if (mapped_symbol_files)
+    flags |= OBJF_MAPPED;
+
+#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
+  if (abfd != NULL)
+    {
+
+      /* If we can support mapped symbol files, try to open/reopen the
+         mapped file that corresponds to the file from which we wish to
+         read symbols.  If the objfile is to be mapped, we must malloc
+         the structure itself using the mmap version, and arrange that
+         all memory allocation for the objfile uses the mmap routines.
+         If we are reusing an existing mapped file, from which we get
+         our objfile pointer, we have to make sure that we update the
+         pointers to the alloc/free functions in the obstack, in case
+         these functions have moved within the current gdb.  */
+
+      int fd;
+
+      fd = open_mapped_file (bfd_get_filename (abfd), bfd_get_mtime (abfd),
+			     flags);
+      if (fd >= 0)
+	{
+	  PTR md;
+
+	  if ((md = map_to_file (fd)) == NULL)
+	    {
+	      close (fd);
+	    }
+	  else if ((objfile = (struct objfile *) mmalloc_getkey (md, 0)) != NULL)
+	    {
+	      /* Update memory corruption handler function addresses. */
+	      init_malloc (md);
+	      objfile->md = md;
+	      objfile->mmfd = fd;
+	      /* Update pointers to functions to *our* copies */
+	      obstack_chunkfun (&objfile->psymbol_cache.cache, xmmalloc);
+	      obstack_freefun (&objfile->psymbol_cache.cache, xmfree);
+	      obstack_chunkfun (&objfile->macro_cache.cache, xmmalloc);
+	      obstack_freefun (&objfile->macro_cache.cache, xmfree);
+	      obstack_chunkfun (&objfile->psymbol_obstack, xmmalloc);
+	      obstack_freefun (&objfile->psymbol_obstack, xmfree);
+	      obstack_chunkfun (&objfile->symbol_obstack, xmmalloc);
+	      obstack_freefun (&objfile->symbol_obstack, xmfree);
+	      obstack_chunkfun (&objfile->type_obstack, xmmalloc);
+	      obstack_freefun (&objfile->type_obstack, xmfree);
+	      /* If already in objfile list, unlink it. */
+	      unlink_objfile (objfile);
+	      /* Forget things specific to a particular gdb, may have changed. */
+	      objfile->sf = NULL;
+	    }
+	  else
+	    {
+
+	      /* Set up to detect internal memory corruption.  MUST be
+	         done before the first malloc.  See comments in
+	         init_malloc() and mmcheck().  */
+
+	      init_malloc (md);
+
+	      objfile = (struct objfile *)
+		xmmalloc (md, sizeof (struct objfile));
+	      memset (objfile, 0, sizeof (struct objfile));
+	      objfile->md = md;
+	      objfile->mmfd = fd;
+	      objfile->flags |= OBJF_MAPPED;
+	      mmalloc_setkey (objfile->md, 0, objfile);
+	      obstack_specify_allocation_with_arg (&objfile->psymbol_cache.cache,
+						   0, 0, xmmalloc, xmfree,
+						   objfile->md);
+	      obstack_specify_allocation_with_arg (&objfile->macro_cache.cache,
+						   0, 0, xmmalloc, xmfree,
+						   objfile->md);
+	      obstack_specify_allocation_with_arg (&objfile->psymbol_obstack,
+						   0, 0, xmmalloc, xmfree,
+						   objfile->md);
+	      obstack_specify_allocation_with_arg (&objfile->symbol_obstack,
+						   0, 0, xmmalloc, xmfree,
+						   objfile->md);
+	      obstack_specify_allocation_with_arg (&objfile->type_obstack,
+						   0, 0, xmmalloc, xmfree,
+						   objfile->md);
+	    }
+	}
+
+      if ((flags & OBJF_MAPPED) && (objfile == NULL))
+	{
+	  warning ("symbol table for '%s' will not be mapped",
+		   bfd_get_filename (abfd));
+	  flags &= ~OBJF_MAPPED;
+	}
+    }
+#else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
+
+  if (flags & OBJF_MAPPED)
+    {
+      warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
+
+      /* Turn off the global flag so we don't try to do mapped symbol tables
+         any more, which shuts up gdb unless the user specifically gives the
+         "mapped" keyword again. */
+
+      mapped_symbol_files = 0;
+      flags &= ~OBJF_MAPPED;
+    }
+
+#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
+
+  /* If we don't support mapped symbol files, didn't ask for the file to be
+     mapped, or failed to open the mapped file for some reason, then revert
+     back to an unmapped objfile. */
+
+  if (objfile == NULL)
+    {
+      objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
+      memset (objfile, 0, sizeof (struct objfile));
+      objfile->md = NULL;
+      objfile->psymbol_cache = bcache_xmalloc ();
+      objfile->macro_cache = bcache_xmalloc ();
+      obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,
+				  xfree);
+      obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,
+				  xfree);
+      obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
+				  xfree);
+      flags &= ~OBJF_MAPPED;
+    }
+
+  /* Update the per-objfile information that comes from the bfd, ensuring
+     that any data that is reference is saved in the per-objfile data
+     region. */
+
+  objfile->obfd = abfd;
+  if (objfile->name != NULL)
+    {
+      xmfree (objfile->md, objfile->name);
+    }
+  if (abfd != NULL)
+    {
+      objfile->name = mstrsave (objfile->md, bfd_get_filename (abfd));
+      objfile->mtime = bfd_get_mtime (abfd);
+
+      /* Build section table.  */
+
+      if (build_objfile_section_table (objfile))
+	{
+	  error ("Can't find the file sections in `%s': %s",
+		 objfile->name, bfd_errmsg (bfd_get_error ()));
+	}
+    }
+
+  /* Initialize the section indexes for this objfile, so that we can
+     later detect if they are used w/o being properly assigned to. */
+
+    objfile->sect_index_text = -1;
+    objfile->sect_index_data = -1;
+    objfile->sect_index_bss = -1;
+    objfile->sect_index_rodata = -1;
+
+  /* Add this file onto the tail of the linked list of other such files. */
+
+  objfile->next = NULL;
+  if (object_files == NULL)
+    object_files = objfile;
+  else
+    {
+      for (last_one = object_files;
+	   last_one->next;
+	   last_one = last_one->next);
+      last_one->next = objfile;
+    }
+
+  /* Save passed in flag bits. */
+  objfile->flags |= flags;
+
+  return (objfile);
+}
+
+/* Put OBJFILE at the front of the list.  */
+
+void
+objfile_to_front (struct objfile *objfile)
+{
+  struct objfile **objp;
+  for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
+    {
+      if (*objp == objfile)
+	{
+	  /* Unhook it from where it is.  */
+	  *objp = objfile->next;
+	  /* Put it in the front.  */
+	  objfile->next = object_files;
+	  object_files = objfile;
+	  break;
+	}
+    }
+}
+
+/* Unlink OBJFILE from the list of known objfiles, if it is found in the
+   list.
+
+   It is not a bug, or error, to call this function if OBJFILE is not known
+   to be in the current list.  This is done in the case of mapped objfiles,
+   for example, just to ensure that the mapped objfile doesn't appear twice
+   in the list.  Since the list is threaded, linking in a mapped objfile
+   twice would create a circular list.
+
+   If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
+   unlinking it, just to ensure that we have completely severed any linkages
+   between the OBJFILE and the list. */
+
+void
+unlink_objfile (struct objfile *objfile)
+{
+  struct objfile **objpp;
+
+  for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
+    {
+      if (*objpp == objfile)
+	{
+	  *objpp = (*objpp)->next;
+	  objfile->next = NULL;
+	  return;
+	}
+    }
+
+  internal_error (__FILE__, __LINE__,
+		  "unlink_objfile: objfile already unlinked");
+}
+
+
+/* Destroy an objfile and all the symtabs and psymtabs under it.  Note
+   that as much as possible is allocated on the symbol_obstack and
+   psymbol_obstack, so that the memory can be efficiently freed.
+
+   Things which we do NOT free because they are not in malloc'd memory
+   or not in memory specific to the objfile include:
+
+   objfile -> sf
+
+   FIXME:  If the objfile is using reusable symbol information (via mmalloc),
+   then we need to take into account the fact that more than one process
+   may be using the symbol information at the same time (when mmalloc is
+   extended to support cooperative locking).  When more than one process
+   is using the mapped symbol info, we need to be more careful about when
+   we free objects in the reusable area. */
+
+void
+free_objfile (struct objfile *objfile)
+{
+  /* First do any symbol file specific actions required when we are
+     finished with a particular symbol file.  Note that if the objfile
+     is using reusable symbol information (via mmalloc) then each of
+     these routines is responsible for doing the correct thing, either
+     freeing things which are valid only during this particular gdb
+     execution, or leaving them to be reused during the next one. */
+
+  if (objfile->sf != NULL)
+    {
+      (*objfile->sf->sym_finish) (objfile);
+    }
+
+  /* We always close the bfd. */
+
+  if (objfile->obfd != NULL)
+    {
+      char *name = bfd_get_filename (objfile->obfd);
+      if (!bfd_close (objfile->obfd))
+	warning ("cannot close \"%s\": %s",
+		 name, bfd_errmsg (bfd_get_error ()));
+      xfree (name);
+    }
+
+  /* Remove it from the chain of all objfiles. */
+
+  unlink_objfile (objfile);
+
+  /* If we are going to free the runtime common objfile, mark it
+     as unallocated.  */
+
+  if (objfile == rt_common_objfile)
+    rt_common_objfile = NULL;
+
+  /* Before the symbol table code was redone to make it easier to
+     selectively load and remove information particular to a specific
+     linkage unit, gdb used to do these things whenever the monolithic
+     symbol table was blown away.  How much still needs to be done
+     is unknown, but we play it safe for now and keep each action until
+     it is shown to be no longer needed. */
+
+  /* I *think* all our callers call clear_symtab_users.  If so, no need
+     to call this here.  */
+  clear_pc_function_cache ();
+
+  /* The last thing we do is free the objfile struct itself for the
+     non-reusable case, or detach from the mapped file for the
+     reusable case.  Note that the mmalloc_detach or the xmfree() is
+     the last thing we can do with this objfile. */
+
+#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
+
+  if (objfile->flags & OBJF_MAPPED)
+    {
+      /* Remember the fd so we can close it.  We can't close it before
+         doing the detach, and after the detach the objfile is gone. */
+      int mmfd;
+
+      mmfd = objfile->mmfd;
+      mmalloc_detach (objfile->md);
+      objfile = NULL;
+      close (mmfd);
+    }
+
+#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
+
+  /* If we still have an objfile, then either we don't support reusable
+     objfiles or this one was not reusable.  So free it normally. */
+
+  if (objfile != NULL)
+    {
+      if (objfile->name != NULL)
+	{
+	  xmfree (objfile->md, objfile->name);
+	}
+      if (objfile->global_psymbols.list)
+	xmfree (objfile->md, objfile->global_psymbols.list);
+      if (objfile->static_psymbols.list)
+	xmfree (objfile->md, objfile->static_psymbols.list);
+      /* Free the obstacks for non-reusable objfiles */
+      bcache_xfree (objfile->psymbol_cache);
+      bcache_xfree (objfile->macro_cache);
+      obstack_free (&objfile->psymbol_obstack, 0);
+      obstack_free (&objfile->symbol_obstack, 0);
+      obstack_free (&objfile->type_obstack, 0);
+      xmfree (objfile->md, objfile);
+      objfile = NULL;
+    }
+}
+
+static void
+do_free_objfile_cleanup (void *obj)
+{
+  free_objfile (obj);
+}
+
+struct cleanup *
+make_cleanup_free_objfile (struct objfile *obj)
+{
+  return make_cleanup (do_free_objfile_cleanup, obj);
+}
+
+/* Free all the object files at once and clean up their users.  */
+
+void
+free_all_objfiles (void)
+{
+  struct objfile *objfile, *temp;
+
+  ALL_OBJFILES_SAFE (objfile, temp)
+  {
+    free_objfile (objfile);
+  }
+  clear_symtab_users ();
+}
+
+/* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
+   entries in new_offsets.  */
+void
+objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)
+{
+  struct section_offsets *delta =
+    (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
+
+  {
+    int i;
+    int something_changed = 0;
+    for (i = 0; i < objfile->num_sections; ++i)
+      {
+	delta->offsets[i] =
+	  ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
+	if (ANOFFSET (delta, i) != 0)
+	  something_changed = 1;
+      }
+    if (!something_changed)
+      return;
+  }
+
+  /* OK, get all the symtabs.  */
+  {
+    struct symtab *s;
+
+    ALL_OBJFILE_SYMTABS (objfile, s)
+    {
+      struct linetable *l;
+      struct blockvector *bv;
+      int i;
+
+      /* First the line table.  */
+      l = LINETABLE (s);
+      if (l)
+	{
+	  for (i = 0; i < l->nitems; ++i)
+	    l->item[i].pc += ANOFFSET (delta, s->block_line_section);
+	}
+
+      /* Don't relocate a shared blockvector more than once.  */
+      if (!s->primary)
+	continue;
+
+      bv = BLOCKVECTOR (s);
+      for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
+	{
+	  struct block *b;
+	  struct symbol *sym;
+	  int j;
+
+	  b = BLOCKVECTOR_BLOCK (bv, i);
+	  BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
+	  BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
+
+	  ALL_BLOCK_SYMBOLS (b, j, sym)
+	    {
+	      fixup_symbol_section (sym, objfile);
+
+	      /* The RS6000 code from which this was taken skipped
+	         any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
+	         But I'm leaving out that test, on the theory that
+	         they can't possibly pass the tests below.  */
+	      if ((SYMBOL_CLASS (sym) == LOC_LABEL
+		   || SYMBOL_CLASS (sym) == LOC_STATIC
+		   || SYMBOL_CLASS (sym) == LOC_INDIRECT)
+		  && SYMBOL_SECTION (sym) >= 0)
+		{
+		  SYMBOL_VALUE_ADDRESS (sym) +=
+		    ANOFFSET (delta, SYMBOL_SECTION (sym));
+		}
+#ifdef MIPS_EFI_SYMBOL_NAME
+	      /* Relocate Extra Function Info for ecoff.  */
+
+	      else if (SYMBOL_CLASS (sym) == LOC_CONST
+		       && SYMBOL_NAMESPACE (sym) == LABEL_NAMESPACE
+		       && strcmp (SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
+		ecoff_relocate_efi (sym, ANOFFSET (delta,
+						   s->block_line_section));
+#endif
+	    }
+	}
+    }
+  }
+
+  {
+    struct partial_symtab *p;
+
+    ALL_OBJFILE_PSYMTABS (objfile, p)
+    {
+      p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+      p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+    }
+  }
+
+  {
+    struct partial_symbol **psym;
+
+    for (psym = objfile->global_psymbols.list;
+	 psym < objfile->global_psymbols.next;
+	 psym++)
+      {
+	fixup_psymbol_section (*psym, objfile);
+	if (SYMBOL_SECTION (*psym) >= 0)
+	  SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
+						    SYMBOL_SECTION (*psym));
+      }
+    for (psym = objfile->static_psymbols.list;
+	 psym < objfile->static_psymbols.next;
+	 psym++)
+      {
+	fixup_psymbol_section (*psym, objfile);
+	if (SYMBOL_SECTION (*psym) >= 0)
+	  SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
+						    SYMBOL_SECTION (*psym));
+      }
+  }
+
+  {
+    struct minimal_symbol *msym;
+    ALL_OBJFILE_MSYMBOLS (objfile, msym)
+      if (SYMBOL_SECTION (msym) >= 0)
+      SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
+  }
+  /* Relocating different sections by different amounts may cause the symbols
+     to be out of order.  */
+  msymbols_sort (objfile);
+
+  {
+    int i;
+    for (i = 0; i < objfile->num_sections; ++i)
+      (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
+  }
+
+  if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
+    {
+      /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
+	 only as a fallback.  */
+      struct obj_section *s;
+      s = find_pc_section (objfile->ei.entry_point);
+      if (s)
+        objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
+      else
+        objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+    }
+
+  {
+    struct obj_section *s;
+    bfd *abfd;
+
+    abfd = objfile->obfd;
+
+    ALL_OBJFILE_OSECTIONS (objfile, s)
+      {
+      	int idx = s->the_bfd_section->index;
+	
+	s->addr += ANOFFSET (delta, idx);
+	s->endaddr += ANOFFSET (delta, idx);
+      }
+  }
+
+  if (objfile->ei.entry_func_lowpc != INVALID_ENTRY_LOWPC)
+    {
+      objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+      objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+    }
+
+  if (objfile->ei.entry_file_lowpc != INVALID_ENTRY_LOWPC)
+    {
+      objfile->ei.entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+      objfile->ei.entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+    }
+
+  if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC)
+    {
+      objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+      objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+    }
+
+  /* Relocate breakpoints as necessary, after things are relocated. */
+  breakpoint_re_set ();
+}
+
+/* Many places in gdb want to test just to see if we have any partial
+   symbols available.  This function returns zero if none are currently
+   available, nonzero otherwise. */
+
+int
+have_partial_symbols (void)
+{
+  struct objfile *ofp;
+
+  ALL_OBJFILES (ofp)
+  {
+    if (ofp->psymtabs != NULL)
+      {
+	return 1;
+      }
+  }
+  return 0;
+}
+
+/* Many places in gdb want to test just to see if we have any full
+   symbols available.  This function returns zero if none are currently
+   available, nonzero otherwise. */
+
+int
+have_full_symbols (void)
+{
+  struct objfile *ofp;
+
+  ALL_OBJFILES (ofp)
+  {
+    if (ofp->symtabs != NULL)
+      {
+	return 1;
+      }
+  }
+  return 0;
+}
+
+
+/* This operations deletes all objfile entries that represent solibs that
+   weren't explicitly loaded by the user, via e.g., the add-symbol-file
+   command.
+ */
+void
+objfile_purge_solibs (void)
+{
+  struct objfile *objf;
+  struct objfile *temp;
+
+  ALL_OBJFILES_SAFE (objf, temp)
+  {
+    /* We assume that the solib package has been purged already, or will
+       be soon.
+     */
+    if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
+      free_objfile (objf);
+  }
+}
+
+
+/* Many places in gdb want to test just to see if we have any minimal
+   symbols available.  This function returns zero if none are currently
+   available, nonzero otherwise. */
+
+int
+have_minimal_symbols (void)
+{
+  struct objfile *ofp;
+
+  ALL_OBJFILES (ofp)
+  {
+    if (ofp->msymbols != NULL)
+      {
+	return 1;
+      }
+  }
+  return 0;
+}
+
+#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
+
+/* Given the name of a mapped symbol file in SYMSFILENAME, and the timestamp
+   of the corresponding symbol file in MTIME, try to open an existing file
+   with the name SYMSFILENAME and verify it is more recent than the base
+   file by checking it's timestamp against MTIME.
+
+   If SYMSFILENAME does not exist (or can't be stat'd), simply returns -1.
+
+   If SYMSFILENAME does exist, but is out of date, we check to see if the
+   user has specified creation of a mapped file.  If so, we don't issue
+   any warning message because we will be creating a new mapped file anyway,
+   overwriting the old one.  If not, then we issue a warning message so that
+   the user will know why we aren't using this existing mapped symbol file.
+   In either case, we return -1.
+
+   If SYMSFILENAME does exist and is not out of date, but can't be opened for
+   some reason, then prints an appropriate system error message and returns -1.
+
+   Otherwise, returns the open file descriptor.  */
+
+static int
+open_existing_mapped_file (char *symsfilename, long mtime, int flags)
+{
+  int fd = -1;
+  struct stat sbuf;
+
+  if (stat (symsfilename, &sbuf) == 0)
+    {
+      if (sbuf.st_mtime < mtime)
+	{
+	  if (!(flags & OBJF_MAPPED))
+	    {
+	      warning ("mapped symbol file `%s' is out of date, ignored it",
+		       symsfilename);
+	    }
+	}
+      else if ((fd = open (symsfilename, O_RDWR)) < 0)
+	{
+	  if (error_pre_print)
+	    {
+	      printf_unfiltered (error_pre_print);
+	    }
+	  print_sys_errmsg (symsfilename, errno);
+	}
+    }
+  return (fd);
+}
+
+/* Look for a mapped symbol file that corresponds to FILENAME and is more
+   recent than MTIME.  If MAPPED is nonzero, the user has asked that gdb
+   use a mapped symbol file for this file, so create a new one if one does
+   not currently exist.
+
+   If found, then return an open file descriptor for the file, otherwise
+   return -1.
+
+   This routine is responsible for implementing the policy that generates
+   the name of the mapped symbol file from the name of a file containing
+   symbols that gdb would like to read.  Currently this policy is to append
+   ".syms" to the name of the file.
+
+   This routine is also responsible for implementing the policy that
+   determines where the mapped symbol file is found (the search path).
+   This policy is that when reading an existing mapped file, a file of
+   the correct name in the current directory takes precedence over a
+   file of the correct name in the same directory as the symbol file.
+   When creating a new mapped file, it is always created in the current
+   directory.  This helps to minimize the chances of a user unknowingly
+   creating big mapped files in places like /bin and /usr/local/bin, and
+   allows a local copy to override a manually installed global copy (in
+   /bin for example).  */
+
+static int
+open_mapped_file (char *filename, long mtime, int flags)
+{
+  int fd;
+  char *symsfilename;
+
+  /* First try to open an existing file in the current directory, and
+     then try the directory where the symbol file is located. */
+
+  symsfilename = concat ("./", lbasename (filename), ".syms", (char *) NULL);
+  if ((fd = open_existing_mapped_file (symsfilename, mtime, flags)) < 0)
+    {
+      xfree (symsfilename);
+      symsfilename = concat (filename, ".syms", (char *) NULL);
+      fd = open_existing_mapped_file (symsfilename, mtime, flags);
+    }
+
+  /* If we don't have an open file by now, then either the file does not
+     already exist, or the base file has changed since it was created.  In
+     either case, if the user has specified use of a mapped file, then
+     create a new mapped file, truncating any existing one.  If we can't
+     create one, print a system error message saying why we can't.
+
+     By default the file is rw for everyone, with the user's umask taking
+     care of turning off the permissions the user wants off. */
+
+  if ((fd < 0) && (flags & OBJF_MAPPED))
+    {
+      xfree (symsfilename);
+      symsfilename = concat ("./", lbasename (filename), ".syms",
+			     (char *) NULL);
+      if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
+	{
+	  if (error_pre_print)
+	    {
+	      printf_unfiltered (error_pre_print);
+	    }
+	  print_sys_errmsg (symsfilename, errno);
+	}
+    }
+
+  xfree (symsfilename);
+  return (fd);
+}
+
+static PTR
+map_to_file (int fd)
+{
+  PTR md;
+  CORE_ADDR mapto;
+
+  md = mmalloc_attach (fd, (PTR) 0);
+  if (md != NULL)
+    {
+      mapto = (CORE_ADDR) mmalloc_getkey (md, 1);
+      md = mmalloc_detach (md);
+      if (md != NULL)
+	{
+	  /* FIXME: should figure out why detach failed */
+	  md = NULL;
+	}
+      else if (mapto != (CORE_ADDR) NULL)
+	{
+	  /* This mapping file needs to be remapped at "mapto" */
+	  md = mmalloc_attach (fd, (PTR) mapto);
+	}
+      else
+	{
+	  /* This is a freshly created mapping file. */
+	  mapto = (CORE_ADDR) mmalloc_findbase (20 * 1024 * 1024);
+	  if (mapto != 0)
+	    {
+	      /* To avoid reusing the freshly created mapping file, at the 
+	         address selected by mmap, we must truncate it before trying
+	         to do an attach at the address we want. */
+	      ftruncate (fd, 0);
+	      md = mmalloc_attach (fd, (PTR) mapto);
+	      if (md != NULL)
+		{
+		  mmalloc_setkey (md, 1, (PTR) mapto);
+		}
+	    }
+	}
+    }
+  return (md);
+}
+
+#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
+
+/* Returns a section whose range includes PC and SECTION, 
+   or NULL if none found.  Note the distinction between the return type, 
+   struct obj_section (which is defined in gdb), and the input type
+   struct sec (which is a bfd-defined data type).  The obj_section
+   contains a pointer to the bfd struct sec section.  */
+
+struct obj_section *
+find_pc_sect_section (CORE_ADDR pc, struct sec *section)
+{
+  struct obj_section *s;
+  struct objfile *objfile;
+
+  ALL_OBJSECTIONS (objfile, s)
+    if ((section == 0 || section == s->the_bfd_section) &&
+	s->addr <= pc && pc < s->endaddr)
+      return (s);
+
+  return (NULL);
+}
+
+/* Returns a section whose range includes PC or NULL if none found. 
+   Backward compatibility, no section.  */
+
+struct obj_section *
+find_pc_section (CORE_ADDR pc)
+{
+  return find_pc_sect_section (pc, find_pc_mapped_section (pc));
+}
+
+
+/* In SVR4, we recognize a trampoline by it's section name. 
+   That is, if the pc is in a section named ".plt" then we are in
+   a trampoline.  */
+
+int
+in_plt_section (CORE_ADDR pc, char *name)
+{
+  struct obj_section *s;
+  int retval = 0;
+
+  s = find_pc_section (pc);
+
+  retval = (s != NULL
+	    && s->the_bfd_section->name != NULL
+	    && STREQ (s->the_bfd_section->name, ".plt"));
+  return (retval);
+}
+
+/* Return nonzero if NAME is in the import list of OBJFILE.  Else
+   return zero.  */
+
+int
+is_in_import_list (char *name, struct objfile *objfile)
+{
+  register int i;
+
+  if (!objfile || !name || !*name)
+    return 0;
+
+  for (i = 0; i < objfile->import_list_size; i++)
+    if (objfile->import_list[i] && STREQ (name, objfile->import_list[i]))
+      return 1;
+  return 0;
+}
+
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
new file mode 100644
index 0000000..8542b8a
--- /dev/null
+++ b/gdb/printcmd.c
@@ -0,0 +1,2572 @@
+/* Print values for GNU debugger GDB.
+
+   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
+   Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "gdb_string.h"
+#include "frame.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "value.h"
+#include "language.h"
+#include "expression.h"
+#include "gdbcore.h"
+#include "gdbcmd.h"
+#include "target.h"
+#include "breakpoint.h"
+#include "demangle.h"
+#include "valprint.h"
+#include "annotate.h"
+#include "symfile.h"		/* for overlay functions */
+#include "objfiles.h"		/* ditto */
+#include "completer.h"		/* for completion functions */
+#include "ui-out.h"
+#include "gdb_assert.h"
+
+extern int asm_demangle;	/* Whether to demangle syms in asm printouts */
+extern int addressprint;	/* Whether to print hex addresses in HLL " */
+
+struct format_data
+  {
+    int count;
+    char format;
+    char size;
+  };
+
+/* Last specified output format.  */
+
+static char last_format = 'x';
+
+/* Last specified examination size.  'b', 'h', 'w' or `q'.  */
+
+static char last_size = 'w';
+
+/* Default address to examine next.  */
+
+static CORE_ADDR next_address;
+
+/* Default section to examine next. */
+
+static asection *next_section;
+
+/* Last address examined.  */
+
+static CORE_ADDR last_examine_address;
+
+/* Contents of last address examined.
+   This is not valid past the end of the `x' command!  */
+
+static struct value *last_examine_value;
+
+/* Largest offset between a symbolic value and an address, that will be
+   printed as `0x1234 <symbol+offset>'.  */
+
+static unsigned int max_symbolic_offset = UINT_MAX;
+
+/* Append the source filename and linenumber of the symbol when
+   printing a symbolic value as `<symbol at filename:linenum>' if set.  */
+static int print_symbol_filename = 0;
+
+/* Number of auto-display expression currently being displayed.
+   So that we can disable it if we get an error or a signal within it.
+   -1 when not doing one.  */
+
+int current_display_number;
+
+/* Flag to low-level print routines that this value is being printed
+   in an epoch window.  We'd like to pass this as a parameter, but
+   every routine would need to take it.  Perhaps we can encapsulate
+   this in the I/O stream once we have GNU stdio. */
+
+int inspect_it = 0;
+
+struct display
+  {
+    /* Chain link to next auto-display item.  */
+    struct display *next;
+    /* Expression to be evaluated and displayed.  */
+    struct expression *exp;
+    /* Item number of this auto-display item.  */
+    int number;
+    /* Display format specified.  */
+    struct format_data format;
+    /* Innermost block required by this expression when evaluated */
+    struct block *block;
+    /* Status of this display (enabled or disabled) */
+    int enabled_p;
+  };
+
+/* Chain of expressions whose values should be displayed
+   automatically each time the program stops.  */
+
+static struct display *display_chain;
+
+static int display_number;
+
+/* Prototypes for exported functions. */
+
+void output_command (char *, int);
+
+void _initialize_printcmd (void);
+
+/* Prototypes for local functions. */
+
+static void delete_display (int);
+
+static void enable_display (char *, int);
+
+static void disable_display_command (char *, int);
+
+static void disassemble_command (char *, int);
+
+static void printf_command (char *, int);
+
+static void print_frame_nameless_args (struct frame_info *, long,
+				       int, int, struct ui_file *);
+
+static void display_info (char *, int);
+
+static void do_one_display (struct display *);
+
+static void undisplay_command (char *, int);
+
+static void free_display (struct display *);
+
+static void display_command (char *, int);
+
+void x_command (char *, int);
+
+static void address_info (char *, int);
+
+static void set_command (char *, int);
+
+static void call_command (char *, int);
+
+static void inspect_command (char *, int);
+
+static void print_command (char *, int);
+
+static void print_command_1 (char *, int, int);
+
+static void validate_format (struct format_data, char *);
+
+static void do_examine (struct format_data, CORE_ADDR addr,
+			asection * section);
+
+static void print_formatted (struct value *, int, int, struct ui_file *);
+
+static struct format_data decode_format (char **, int, int);
+
+static int print_insn (CORE_ADDR, struct ui_file *);
+
+static void sym_info (char *, int);
+
+
+/* Decode a format specification.  *STRING_PTR should point to it.
+   OFORMAT and OSIZE are used as defaults for the format and size
+   if none are given in the format specification.
+   If OSIZE is zero, then the size field of the returned value
+   should be set only if a size is explicitly specified by the
+   user.
+   The structure returned describes all the data
+   found in the specification.  In addition, *STRING_PTR is advanced
+   past the specification and past all whitespace following it.  */
+
+static struct format_data
+decode_format (char **string_ptr, int oformat, int osize)
+{
+  struct format_data val;
+  register char *p = *string_ptr;
+
+  val.format = '?';
+  val.size = '?';
+  val.count = 1;
+
+  if (*p >= '0' && *p <= '9')
+    val.count = atoi (p);
+  while (*p >= '0' && *p <= '9')
+    p++;
+
+  /* Now process size or format letters that follow.  */
+
+  while (1)
+    {
+      if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
+	val.size = *p++;
+      else if (*p >= 'a' && *p <= 'z')
+	val.format = *p++;
+      else
+	break;
+    }
+
+  while (*p == ' ' || *p == '\t')
+    p++;
+  *string_ptr = p;
+
+  /* Set defaults for format and size if not specified.  */
+  if (val.format == '?')
+    {
+      if (val.size == '?')
+	{
+	  /* Neither has been specified.  */
+	  val.format = oformat;
+	  val.size = osize;
+	}
+      else
+	/* If a size is specified, any format makes a reasonable
+	   default except 'i'.  */
+	val.format = oformat == 'i' ? 'x' : oformat;
+    }
+  else if (val.size == '?')
+    switch (val.format)
+      {
+      case 'a':
+      case 's':
+	/* Pick the appropriate size for an address.  */
+	if (TARGET_PTR_BIT == 64)
+	  val.size = osize ? 'g' : osize;
+	else if (TARGET_PTR_BIT == 32)
+	  val.size = osize ? 'w' : osize;
+	else if (TARGET_PTR_BIT == 16)
+	  val.size = osize ? 'h' : osize;
+	else
+	  /* Bad value for TARGET_PTR_BIT */
+	  internal_error (__FILE__, __LINE__, "failed internal consistency check");
+	break;
+      case 'f':
+	/* Floating point has to be word or giantword.  */
+	if (osize == 'w' || osize == 'g')
+	  val.size = osize;
+	else
+	  /* Default it to giantword if the last used size is not
+	     appropriate.  */
+	  val.size = osize ? 'g' : osize;
+	break;
+      case 'c':
+	/* Characters default to one byte.  */
+	val.size = osize ? 'b' : osize;
+	break;
+      default:
+	/* The default is the size most recently specified.  */
+	val.size = osize;
+      }
+
+  return val;
+}
+
+/* Print value VAL on stream according to FORMAT, a letter or 0.
+   Do not end with a newline.
+   0 means print VAL according to its own type.
+   SIZE is the letter for the size of datum being printed.
+   This is used to pad hex numbers so they line up.  */
+
+static void
+print_formatted (struct value *val, register int format, int size,
+		 struct ui_file *stream)
+{
+  struct type *type = check_typedef (VALUE_TYPE (val));
+  int len = TYPE_LENGTH (type);
+
+  if (VALUE_LVAL (val) == lval_memory)
+    {
+      next_address = VALUE_ADDRESS (val) + len;
+      next_section = VALUE_BFD_SECTION (val);
+    }
+
+  switch (format)
+    {
+    case 's':
+      /* FIXME: Need to handle wchar_t's here... */
+      next_address = VALUE_ADDRESS (val)
+	+ val_print_string (VALUE_ADDRESS (val), -1, 1, stream);
+      next_section = VALUE_BFD_SECTION (val);
+      break;
+
+    case 'i':
+      /* The old comment says
+         "Force output out, print_insn not using _filtered".
+         I'm not completely sure what that means, I suspect most print_insn
+         now do use _filtered, so I guess it's obsolete.
+         --Yes, it does filter now, and so this is obsolete.  -JB  */
+
+      /* We often wrap here if there are long symbolic names.  */
+      wrap_here ("    ");
+      next_address = VALUE_ADDRESS (val)
+	+ print_insn (VALUE_ADDRESS (val), stream);
+      next_section = VALUE_BFD_SECTION (val);
+      break;
+
+    default:
+      if (format == 0
+	  || TYPE_CODE (type) == TYPE_CODE_ARRAY
+	  || TYPE_CODE (type) == TYPE_CODE_STRING
+	  || TYPE_CODE (type) == TYPE_CODE_STRUCT
+	  || TYPE_CODE (type) == TYPE_CODE_UNION)
+	/* If format is 0, use the 'natural' format for
+	 * that type of value.  If the type is non-scalar,
+	 * we have to use language rules to print it as
+	 * a series of scalars.
+	 */
+	value_print (val, stream, format, Val_pretty_default);
+      else
+	/* User specified format, so don't look to the
+	 * the type to tell us what to do.
+	 */
+	print_scalar_formatted (VALUE_CONTENTS (val), type,
+				format, size, stream);
+    }
+}
+
+/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
+   according to letters FORMAT and SIZE on STREAM.
+   FORMAT may not be zero.  Formats s and i are not supported at this level.
+
+   This is how the elements of an array or structure are printed
+   with a format.  */
+
+void
+print_scalar_formatted (char *valaddr, struct type *type, int format, int size,
+			struct ui_file *stream)
+{
+  LONGEST val_long;
+  unsigned int len = TYPE_LENGTH (type);
+
+  if (len > sizeof (LONGEST)
+      && (format == 't'
+	  || format == 'c'
+	  || format == 'o'
+	  || format == 'u'
+	  || format == 'd'
+	  || format == 'x'))
+    {
+      if (!TYPE_UNSIGNED (type)
+	  || !extract_long_unsigned_integer (valaddr, len, &val_long))
+	{
+	  /* We can't print it normally, but we can print it in hex.
+	     Printing it in the wrong radix is more useful than saying
+	     "use /x, you dummy".  */
+	  /* FIXME:  we could also do octal or binary if that was the
+	     desired format.  */
+	  /* FIXME:  we should be using the size field to give us a
+	     minimum field width to print.  */
+
+	  if (format == 'o')
+	    print_octal_chars (stream, valaddr, len);
+	  else if (format == 'd')
+	    print_decimal_chars (stream, valaddr, len);
+	  else if (format == 't')
+	    print_binary_chars (stream, valaddr, len);
+	  else
+	    /* replace with call to print_hex_chars? Looks
+	       like val_print_type_code_int is redoing
+	       work.  - edie */
+
+	    val_print_type_code_int (type, valaddr, stream);
+
+	  return;
+	}
+
+      /* If we get here, extract_long_unsigned_integer set val_long.  */
+    }
+  else if (format != 'f')
+    val_long = unpack_long (type, valaddr);
+
+  /* If the value is a pointer, and pointers and addresses are not the
+     same, then at this point, the value's length (in target bytes) is
+     TARGET_ADDR_BIT/TARGET_CHAR_BIT, not TYPE_LENGTH (type).  */
+  if (TYPE_CODE (type) == TYPE_CODE_PTR)
+    len = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
+
+  /* If we are printing it as unsigned, truncate it in case it is actually
+     a negative signed value (e.g. "print/u (short)-1" should print 65535
+     (if shorts are 16 bits) instead of 4294967295).  */
+  if (format != 'd')
+    {
+      if (len < sizeof (LONGEST))
+	val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
+    }
+
+  switch (format)
+    {
+    case 'x':
+      if (!size)
+	{
+	  /* no size specified, like in print.  Print varying # of digits. */
+	  print_longest (stream, 'x', 1, val_long);
+	}
+      else
+	switch (size)
+	  {
+	  case 'b':
+	  case 'h':
+	  case 'w':
+	  case 'g':
+	    print_longest (stream, size, 1, val_long);
+	    break;
+	  default:
+	    error ("Undefined output size \"%c\".", size);
+	  }
+      break;
+
+    case 'd':
+      print_longest (stream, 'd', 1, val_long);
+      break;
+
+    case 'u':
+      print_longest (stream, 'u', 0, val_long);
+      break;
+
+    case 'o':
+      if (val_long)
+	print_longest (stream, 'o', 1, val_long);
+      else
+	fprintf_filtered (stream, "0");
+      break;
+
+    case 'a':
+      {
+	CORE_ADDR addr = unpack_pointer (type, valaddr);
+	print_address (addr, stream);
+      }
+      break;
+
+    case 'c':
+      value_print (value_from_longest (builtin_type_true_char, val_long),
+		   stream, 0, Val_pretty_default);
+      break;
+
+    case 'f':
+      if (len == TYPE_LENGTH (builtin_type_float))
+        type = builtin_type_float;
+      else if (len == TYPE_LENGTH (builtin_type_double))
+        type = builtin_type_double;
+      else if (len == TYPE_LENGTH (builtin_type_long_double))
+        type = builtin_type_long_double;
+      print_floating (valaddr, type, stream);
+      break;
+
+    case 0:
+      internal_error (__FILE__, __LINE__, "failed internal consistency check");
+
+    case 't':
+      /* Binary; 't' stands for "two".  */
+      {
+	char bits[8 * (sizeof val_long) + 1];
+	char buf[8 * (sizeof val_long) + 32];
+	char *cp = bits;
+	int width;
+
+	if (!size)
+	  width = 8 * (sizeof val_long);
+	else
+	  switch (size)
+	    {
+	    case 'b':
+	      width = 8;
+	      break;
+	    case 'h':
+	      width = 16;
+	      break;
+	    case 'w':
+	      width = 32;
+	      break;
+	    case 'g':
+	      width = 64;
+	      break;
+	    default:
+	      error ("Undefined output size \"%c\".", size);
+	    }
+
+	bits[width] = '\0';
+	while (width-- > 0)
+	  {
+	    bits[width] = (val_long & 1) ? '1' : '0';
+	    val_long >>= 1;
+	  }
+	if (!size)
+	  {
+	    while (*cp && *cp == '0')
+	      cp++;
+	    if (*cp == '\0')
+	      cp--;
+	  }
+	strcpy (buf, local_binary_format_prefix ());
+	strcat (buf, cp);
+	strcat (buf, local_binary_format_suffix ());
+	fprintf_filtered (stream, buf);
+      }
+      break;
+
+    default:
+      error ("Undefined output format \"%c\".", format);
+    }
+}
+
+/* Specify default address for `x' command.
+   `info lines' uses this.  */
+
+void
+set_next_address (CORE_ADDR addr)
+{
+  next_address = addr;
+
+  /* Make address available to the user as $_.  */
+  set_internalvar (lookup_internalvar ("_"),
+		   value_from_pointer (lookup_pointer_type (builtin_type_void),
+				       addr));
+}
+
+/* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
+   after LEADIN.  Print nothing if no symbolic name is found nearby.
+   Optionally also print source file and line number, if available.
+   DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
+   or to interpret it as a possible C++ name and convert it back to source
+   form.  However note that DO_DEMANGLE can be overridden by the specific
+   settings of the demangle and asm_demangle variables.  */
+
+void
+print_address_symbolic (CORE_ADDR addr, struct ui_file *stream, int do_demangle,
+			char *leadin)
+{
+  char *name = NULL;
+  char *filename = NULL;
+  int unmapped = 0;
+  int offset = 0;
+  int line = 0;
+
+  /* throw away both name and filename */
+  struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
+  make_cleanup (free_current_contents, &filename);
+
+  if (build_address_symbolic (addr, do_demangle, &name, &offset, &filename, &line, &unmapped))
+    {
+      do_cleanups (cleanup_chain);
+      return;
+    }
+
+  fputs_filtered (leadin, stream);
+  if (unmapped)
+    fputs_filtered ("<*", stream);
+  else
+    fputs_filtered ("<", stream);
+  fputs_filtered (name, stream);
+  if (offset != 0)
+    fprintf_filtered (stream, "+%u", (unsigned int) offset);
+
+  /* Append source filename and line number if desired.  Give specific
+     line # of this addr, if we have it; else line # of the nearest symbol.  */
+  if (print_symbol_filename && filename != NULL)
+    {
+      if (line != -1)
+	fprintf_filtered (stream, " at %s:%d", filename, line);
+      else
+	fprintf_filtered (stream, " in %s", filename);
+    }
+  if (unmapped)
+    fputs_filtered ("*>", stream);
+  else
+    fputs_filtered (">", stream);
+
+  do_cleanups (cleanup_chain);
+}
+
+/* Given an address ADDR return all the elements needed to print the
+   address in a symbolic form. NAME can be mangled or not depending
+   on DO_DEMANGLE (and also on the asm_demangle global variable,
+   manipulated via ''set print asm-demangle''). Return 0 in case of
+   success, when all the info in the OUT paramters is valid. Return 1
+   otherwise. */
+int
+build_address_symbolic (CORE_ADDR addr,  /* IN */
+			int do_demangle, /* IN */
+			char **name,     /* OUT */
+			int *offset,     /* OUT */
+			char **filename, /* OUT */
+			int *line,       /* OUT */
+			int *unmapped)   /* OUT */
+{
+  struct minimal_symbol *msymbol;
+  struct symbol *symbol;
+  struct symtab *symtab = 0;
+  CORE_ADDR name_location = 0;
+  asection *section = 0;
+  char *name_temp = "";
+  
+  /* Let's say it is unmapped. */
+  *unmapped = 0;
+
+  /* Determine if the address is in an overlay, and whether it is
+     mapped. */
+  if (overlay_debugging)
+    {
+      section = find_pc_overlay (addr);
+      if (pc_in_unmapped_range (addr, section))
+	{
+	  *unmapped = 1;
+	  addr = overlay_mapped_address (addr, section);
+	}
+    }
+
+  /* On some targets, add in extra "flag" bits to PC for
+     disassembly.  This should ensure that "rounding errors" in
+     symbol addresses that are masked for disassembly favour the
+     the correct symbol. */
+
+#ifdef GDB_TARGET_UNMASK_DISAS_PC
+  addr = GDB_TARGET_UNMASK_DISAS_PC (addr);
+#endif
+
+  /* First try to find the address in the symbol table, then
+     in the minsyms.  Take the closest one.  */
+
+  /* This is defective in the sense that it only finds text symbols.  So
+     really this is kind of pointless--we should make sure that the
+     minimal symbols have everything we need (by changing that we could
+     save some memory, but for many debug format--ELF/DWARF or
+     anything/stabs--it would be inconvenient to eliminate those minimal
+     symbols anyway).  */
+  msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
+  symbol = find_pc_sect_function (addr, section);
+
+  if (symbol)
+    {
+      name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
+      if (do_demangle)
+	name_temp = SYMBOL_SOURCE_NAME (symbol);
+      else
+	name_temp = SYMBOL_LINKAGE_NAME (symbol);
+    }
+
+  if (msymbol != NULL)
+    {
+      if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
+	{
+	  /* The msymbol is closer to the address than the symbol;
+	     use the msymbol instead.  */
+	  symbol = 0;
+	  symtab = 0;
+	  name_location = SYMBOL_VALUE_ADDRESS (msymbol);
+	  if (do_demangle)
+	    name_temp = SYMBOL_SOURCE_NAME (msymbol);
+	  else
+	    name_temp = SYMBOL_LINKAGE_NAME (msymbol);
+	}
+    }
+  if (symbol == NULL && msymbol == NULL)
+    return 1;
+
+  /* On some targets, mask out extra "flag" bits from PC for handsome
+     disassembly. */
+
+#ifdef GDB_TARGET_MASK_DISAS_PC
+  name_location = GDB_TARGET_MASK_DISAS_PC (name_location);
+  addr = GDB_TARGET_MASK_DISAS_PC (addr);
+#endif
+
+  /* If the nearest symbol is too far away, don't print anything symbolic.  */
+
+  /* For when CORE_ADDR is larger than unsigned int, we do math in
+     CORE_ADDR.  But when we detect unsigned wraparound in the
+     CORE_ADDR math, we ignore this test and print the offset,
+     because addr+max_symbolic_offset has wrapped through the end
+     of the address space back to the beginning, giving bogus comparison.  */
+  if (addr > name_location + max_symbolic_offset
+      && name_location + max_symbolic_offset > name_location)
+    return 1;
+
+  *offset = addr - name_location;
+
+  *name = xstrdup (name_temp);
+
+  if (print_symbol_filename)
+    {
+      struct symtab_and_line sal;
+
+      sal = find_pc_sect_line (addr, section, 0);
+
+      if (sal.symtab)
+	{
+	  *filename = xstrdup (sal.symtab->filename);
+	  *line = sal.line;
+	}
+      else if (symtab && symbol && symbol->line)
+	{
+	  *filename = xstrdup (symtab->filename);
+	  *line = symbol->line;
+	}
+      else if (symtab)
+	{
+	  *filename = xstrdup (symtab->filename);
+	  *line = -1;
+	}
+    }
+  return 0;
+}
+
+/* Print address ADDR on STREAM.  USE_LOCAL means the same thing as for
+   print_longest.  */
+void
+print_address_numeric (CORE_ADDR addr, int use_local, struct ui_file *stream)
+{
+  /* Truncate address to the size of a target address, avoiding shifts
+     larger or equal than the width of a CORE_ADDR.  The local
+     variable ADDR_BIT stops the compiler reporting a shift overflow
+     when it won't occur. */
+  /* NOTE: This assumes that the significant address information is
+     kept in the least significant bits of ADDR - the upper bits were
+     either zero or sign extended.  Should ADDRESS_TO_POINTER() or
+     some ADDRESS_TO_PRINTABLE() be used to do the conversion?  */
+
+  int addr_bit = TARGET_ADDR_BIT;
+
+  if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
+    addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
+  print_longest (stream, 'x', use_local, (ULONGEST) addr);
+}
+
+/* Print address ADDR symbolically on STREAM.
+   First print it as a number.  Then perhaps print
+   <SYMBOL + OFFSET> after the number.  */
+
+void
+print_address (CORE_ADDR addr, struct ui_file *stream)
+{
+  print_address_numeric (addr, 1, stream);
+  print_address_symbolic (addr, stream, asm_demangle, " ");
+}
+
+/* Print address ADDR symbolically on STREAM.  Parameter DEMANGLE
+   controls whether to print the symbolic name "raw" or demangled.
+   Global setting "addressprint" controls whether to print hex address
+   or not.  */
+
+void
+print_address_demangle (CORE_ADDR addr, struct ui_file *stream, int do_demangle)
+{
+  if (addr == 0)
+    {
+      fprintf_filtered (stream, "0");
+    }
+  else if (addressprint)
+    {
+      print_address_numeric (addr, 1, stream);
+      print_address_symbolic (addr, stream, do_demangle, " ");
+    }
+  else
+    {
+      print_address_symbolic (addr, stream, do_demangle, "");
+    }
+}
+
+
+/* These are the types that $__ will get after an examine command of one
+   of these sizes.  */
+
+static struct type *examine_i_type;
+
+static struct type *examine_b_type;
+static struct type *examine_h_type;
+static struct type *examine_w_type;
+static struct type *examine_g_type;
+
+/* Examine data at address ADDR in format FMT.
+   Fetch it from memory and print on gdb_stdout.  */
+
+static void
+do_examine (struct format_data fmt, CORE_ADDR addr, asection *sect)
+{
+  register char format = 0;
+  register char size;
+  register int count = 1;
+  struct type *val_type = NULL;
+  register int i;
+  register int maxelts;
+
+  format = fmt.format;
+  size = fmt.size;
+  count = fmt.count;
+  next_address = addr;
+  next_section = sect;
+
+  /* String or instruction format implies fetch single bytes
+     regardless of the specified size.  */
+  if (format == 's' || format == 'i')
+    size = 'b';
+
+  if (format == 'i')
+    val_type = examine_i_type;
+  else if (size == 'b')
+    val_type = examine_b_type;
+  else if (size == 'h')
+    val_type = examine_h_type;
+  else if (size == 'w')
+    val_type = examine_w_type;
+  else if (size == 'g')
+    val_type = examine_g_type;
+
+  maxelts = 8;
+  if (size == 'w')
+    maxelts = 4;
+  if (size == 'g')
+    maxelts = 2;
+  if (format == 's' || format == 'i')
+    maxelts = 1;
+
+  /* Print as many objects as specified in COUNT, at most maxelts per line,
+     with the address of the next one at the start of each line.  */
+
+  while (count > 0)
+    {
+      QUIT;
+      print_address (next_address, gdb_stdout);
+      printf_filtered (":");
+      for (i = maxelts;
+	   i > 0 && count > 0;
+	   i--, count--)
+	{
+	  printf_filtered ("\t");
+	  /* Note that print_formatted sets next_address for the next
+	     object.  */
+	  last_examine_address = next_address;
+
+	  if (last_examine_value)
+	    value_free (last_examine_value);
+
+	  /* The value to be displayed is not fetched greedily.
+	     Instead, to avoid the posibility of a fetched value not
+	     being used, its retreval is delayed until the print code
+	     uses it.  When examining an instruction stream, the
+	     disassembler will perform its own memory fetch using just
+	     the address stored in LAST_EXAMINE_VALUE.  FIXME: Should
+	     the disassembler be modified so that LAST_EXAMINE_VALUE
+	     is left with the byte sequence from the last complete
+	     instruction fetched from memory? */
+	  last_examine_value = value_at_lazy (val_type, next_address, sect);
+
+	  if (last_examine_value)
+	    release_value (last_examine_value);
+
+	  print_formatted (last_examine_value, format, size, gdb_stdout);
+	}
+      printf_filtered ("\n");
+      gdb_flush (gdb_stdout);
+    }
+}
+
+static void
+validate_format (struct format_data fmt, char *cmdname)
+{
+  if (fmt.size != 0)
+    error ("Size letters are meaningless in \"%s\" command.", cmdname);
+  if (fmt.count != 1)
+    error ("Item count other than 1 is meaningless in \"%s\" command.",
+	   cmdname);
+  if (fmt.format == 'i' || fmt.format == 's')
+    error ("Format letter \"%c\" is meaningless in \"%s\" command.",
+	   fmt.format, cmdname);
+}
+
+/*  Evaluate string EXP as an expression in the current language and
+   print the resulting value.  EXP may contain a format specifier as the
+   first argument ("/x myvar" for example, to print myvar in hex).
+ */
+
+static void
+print_command_1 (char *exp, int inspect, int voidprint)
+{
+  struct expression *expr;
+  register struct cleanup *old_chain = 0;
+  register char format = 0;
+  struct value *val;
+  struct format_data fmt;
+  int cleanup = 0;
+
+  /* Pass inspect flag to the rest of the print routines in a global (sigh). */
+  inspect_it = inspect;
+
+  if (exp && *exp == '/')
+    {
+      exp++;
+      fmt = decode_format (&exp, last_format, 0);
+      validate_format (fmt, "print");
+      last_format = format = fmt.format;
+    }
+  else
+    {
+      fmt.count = 1;
+      fmt.format = 0;
+      fmt.size = 0;
+    }
+
+  if (exp && *exp)
+    {
+      struct type *type;
+      expr = parse_expression (exp);
+      old_chain = make_cleanup (free_current_contents, &expr);
+      cleanup = 1;
+      val = evaluate_expression (expr);
+    }
+  else
+    val = access_value_history (0);
+
+  if (voidprint || (val && VALUE_TYPE (val) &&
+		    TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_VOID))
+    {
+      int histindex = record_latest_value (val);
+
+      if (histindex >= 0)
+	annotate_value_history_begin (histindex, VALUE_TYPE (val));
+      else
+	annotate_value_begin (VALUE_TYPE (val));
+
+      if (inspect)
+	printf_unfiltered ("\031(gdb-makebuffer \"%s\"  %d '(\"", exp, histindex);
+      else if (histindex >= 0)
+	printf_filtered ("$%d = ", histindex);
+
+      if (histindex >= 0)
+	annotate_value_history_value ();
+
+      print_formatted (val, format, fmt.size, gdb_stdout);
+      printf_filtered ("\n");
+
+      if (histindex >= 0)
+	annotate_value_history_end ();
+      else
+	annotate_value_end ();
+
+      if (inspect)
+	printf_unfiltered ("\") )\030");
+    }
+
+  if (cleanup)
+    do_cleanups (old_chain);
+  inspect_it = 0;		/* Reset print routines to normal */
+}
+
+/* ARGSUSED */
+static void
+print_command (char *exp, int from_tty)
+{
+  print_command_1 (exp, 0, 1);
+}
+
+/* Same as print, except in epoch, it gets its own window */
+/* ARGSUSED */
+static void
+inspect_command (char *exp, int from_tty)
+{
+  extern int epoch_interface;
+
+  print_command_1 (exp, epoch_interface, 1);
+}
+
+/* Same as print, except it doesn't print void results. */
+/* ARGSUSED */
+static void
+call_command (char *exp, int from_tty)
+{
+  print_command_1 (exp, 0, 0);
+}
+
+/* ARGSUSED */
+void
+output_command (char *exp, int from_tty)
+{
+  struct expression *expr;
+  register struct cleanup *old_chain;
+  register char format = 0;
+  struct value *val;
+  struct format_data fmt;
+
+  if (exp && *exp == '/')
+    {
+      exp++;
+      fmt = decode_format (&exp, 0, 0);
+      validate_format (fmt, "output");
+      format = fmt.format;
+    }
+
+  expr = parse_expression (exp);
+  old_chain = make_cleanup (free_current_contents, &expr);
+
+  val = evaluate_expression (expr);
+
+  annotate_value_begin (VALUE_TYPE (val));
+
+  print_formatted (val, format, fmt.size, gdb_stdout);
+
+  annotate_value_end ();
+
+  wrap_here ("");
+  gdb_flush (gdb_stdout);
+
+  do_cleanups (old_chain);
+}
+
+/* ARGSUSED */
+static void
+set_command (char *exp, int from_tty)
+{
+  struct expression *expr = parse_expression (exp);
+  register struct cleanup *old_chain =
+    make_cleanup (free_current_contents, &expr);
+  evaluate_expression (expr);
+  do_cleanups (old_chain);
+}
+
+/* ARGSUSED */
+static void
+sym_info (char *arg, int from_tty)
+{
+  struct minimal_symbol *msymbol;
+  struct objfile *objfile;
+  struct obj_section *osect;
+  asection *sect;
+  CORE_ADDR addr, sect_addr;
+  int matches = 0;
+  unsigned int offset;
+
+  if (!arg)
+    error_no_arg ("address");
+
+  addr = parse_and_eval_address (arg);
+  ALL_OBJSECTIONS (objfile, osect)
+  {
+    sect = osect->the_bfd_section;
+    sect_addr = overlay_mapped_address (addr, sect);
+
+    if (osect->addr <= sect_addr && sect_addr < osect->endaddr &&
+	(msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, sect)))
+      {
+	matches = 1;
+	offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
+	if (offset)
+	  printf_filtered ("%s + %u in ",
+			   SYMBOL_SOURCE_NAME (msymbol), offset);
+	else
+	  printf_filtered ("%s in ",
+			   SYMBOL_SOURCE_NAME (msymbol));
+	if (pc_in_unmapped_range (addr, sect))
+	  printf_filtered ("load address range of ");
+	if (section_is_overlay (sect))
+	  printf_filtered ("%s overlay ",
+			   section_is_mapped (sect) ? "mapped" : "unmapped");
+	printf_filtered ("section %s", sect->name);
+	printf_filtered ("\n");
+      }
+  }
+  if (matches == 0)
+    printf_filtered ("No symbol matches %s.\n", arg);
+}
+
+/* ARGSUSED */
+static void
+address_info (char *exp, int from_tty)
+{
+  register struct symbol *sym;
+  register struct minimal_symbol *msymbol;
+  register long val;
+  register long basereg;
+  asection *section;
+  CORE_ADDR load_addr;
+  int is_a_field_of_this;	/* C++: lookup_symbol sets this to nonzero
+				   if exp is a field of `this'. */
+
+  if (exp == 0)
+    error ("Argument required.");
+
+  sym = lookup_symbol (exp, get_selected_block (0), VAR_NAMESPACE,
+		       &is_a_field_of_this, (struct symtab **) NULL);
+  if (sym == NULL)
+    {
+      if (is_a_field_of_this)
+	{
+	  printf_filtered ("Symbol \"");
+	  fprintf_symbol_filtered (gdb_stdout, exp,
+				   current_language->la_language, DMGL_ANSI);
+	  printf_filtered ("\" is a field of the local class variable `this'\n");
+	  return;
+	}
+
+      msymbol = lookup_minimal_symbol (exp, NULL, NULL);
+
+      if (msymbol != NULL)
+	{
+	  load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
+
+	  printf_filtered ("Symbol \"");
+	  fprintf_symbol_filtered (gdb_stdout, exp,
+				   current_language->la_language, DMGL_ANSI);
+	  printf_filtered ("\" is at ");
+	  print_address_numeric (load_addr, 1, gdb_stdout);
+	  printf_filtered (" in a file compiled without debugging");
+	  section = SYMBOL_BFD_SECTION (msymbol);
+	  if (section_is_overlay (section))
+	    {
+	      load_addr = overlay_unmapped_address (load_addr, section);
+	      printf_filtered (",\n -- loaded at ");
+	      print_address_numeric (load_addr, 1, gdb_stdout);
+	      printf_filtered (" in overlay section %s", section->name);
+	    }
+	  printf_filtered (".\n");
+	}
+      else
+	error ("No symbol \"%s\" in current context.", exp);
+      return;
+    }
+
+  printf_filtered ("Symbol \"");
+  fprintf_symbol_filtered (gdb_stdout, SYMBOL_NAME (sym),
+			   current_language->la_language, DMGL_ANSI);
+  printf_filtered ("\" is ");
+  val = SYMBOL_VALUE (sym);
+  basereg = SYMBOL_BASEREG (sym);
+  section = SYMBOL_BFD_SECTION (sym);
+
+  switch (SYMBOL_CLASS (sym))
+    {
+    case LOC_CONST:
+    case LOC_CONST_BYTES:
+      printf_filtered ("constant");
+      break;
+
+    case LOC_LABEL:
+      printf_filtered ("a label at address ");
+      print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
+			     1, gdb_stdout);
+      if (section_is_overlay (section))
+	{
+	  load_addr = overlay_unmapped_address (load_addr, section);
+	  printf_filtered (",\n -- loaded at ");
+	  print_address_numeric (load_addr, 1, gdb_stdout);
+	  printf_filtered (" in overlay section %s", section->name);
+	}
+      break;
+
+    case LOC_REGISTER:
+      printf_filtered ("a variable in register %s", REGISTER_NAME (val));
+      break;
+
+    case LOC_STATIC:
+      printf_filtered ("static storage at address ");
+      print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
+			     1, gdb_stdout);
+      if (section_is_overlay (section))
+	{
+	  load_addr = overlay_unmapped_address (load_addr, section);
+	  printf_filtered (",\n -- loaded at ");
+	  print_address_numeric (load_addr, 1, gdb_stdout);
+	  printf_filtered (" in overlay section %s", section->name);
+	}
+      break;
+
+    case LOC_INDIRECT:
+      printf_filtered ("external global (indirect addressing), at address *(");
+      print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
+			     1, gdb_stdout);
+      printf_filtered (")");
+      if (section_is_overlay (section))
+	{
+	  load_addr = overlay_unmapped_address (load_addr, section);
+	  printf_filtered (",\n -- loaded at ");
+	  print_address_numeric (load_addr, 1, gdb_stdout);
+	  printf_filtered (" in overlay section %s", section->name);
+	}
+      break;
+
+    case LOC_REGPARM:
+      printf_filtered ("an argument in register %s", REGISTER_NAME (val));
+      break;
+
+    case LOC_REGPARM_ADDR:
+      printf_filtered ("address of an argument in register %s", REGISTER_NAME (val));
+      break;
+
+    case LOC_ARG:
+      printf_filtered ("an argument at offset %ld", val);
+      break;
+
+    case LOC_LOCAL_ARG:
+      printf_filtered ("an argument at frame offset %ld", val);
+      break;
+
+    case LOC_LOCAL:
+      printf_filtered ("a local variable at frame offset %ld", val);
+      break;
+
+    case LOC_REF_ARG:
+      printf_filtered ("a reference argument at offset %ld", val);
+      break;
+
+    case LOC_BASEREG:
+      printf_filtered ("a variable at offset %ld from register %s",
+		       val, REGISTER_NAME (basereg));
+      break;
+
+    case LOC_BASEREG_ARG:
+      printf_filtered ("an argument at offset %ld from register %s",
+		       val, REGISTER_NAME (basereg));
+      break;
+
+    case LOC_TYPEDEF:
+      printf_filtered ("a typedef");
+      break;
+
+    case LOC_BLOCK:
+      printf_filtered ("a function at address ");
+#ifdef GDB_TARGET_MASK_DISAS_PC
+      print_address_numeric
+	(load_addr = GDB_TARGET_MASK_DISAS_PC (BLOCK_START (SYMBOL_BLOCK_VALUE (sym))),
+	 1, gdb_stdout);
+#else
+      print_address_numeric (load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
+			     1, gdb_stdout);
+#endif
+      if (section_is_overlay (section))
+	{
+	  load_addr = overlay_unmapped_address (load_addr, section);
+	  printf_filtered (",\n -- loaded at ");
+	  print_address_numeric (load_addr, 1, gdb_stdout);
+	  printf_filtered (" in overlay section %s", section->name);
+	}
+      break;
+
+    case LOC_UNRESOLVED:
+      {
+	struct minimal_symbol *msym;
+
+	msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
+	if (msym == NULL)
+	  printf_filtered ("unresolved");
+	else
+	  {
+	    section = SYMBOL_BFD_SECTION (msym);
+	    printf_filtered ("static storage at address ");
+	    print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (msym),
+				   1, gdb_stdout);
+	    if (section_is_overlay (section))
+	      {
+		load_addr = overlay_unmapped_address (load_addr, section);
+		printf_filtered (",\n -- loaded at ");
+		print_address_numeric (load_addr, 1, gdb_stdout);
+		printf_filtered (" in overlay section %s", section->name);
+	      }
+	  }
+      }
+      break;
+
+    case LOC_THREAD_LOCAL_STATIC:
+      printf_filtered (
+			"a thread-local variable at offset %ld from the thread base register %s",
+			val, REGISTER_NAME (basereg));
+      break;
+
+    case LOC_OPTIMIZED_OUT:
+      printf_filtered ("optimized out");
+      break;
+
+    default:
+      printf_filtered ("of unknown (botched) type");
+      break;
+    }
+  printf_filtered (".\n");
+}
+
+void
+x_command (char *exp, int from_tty)
+{
+  struct expression *expr;
+  struct format_data fmt;
+  struct cleanup *old_chain;
+  struct value *val;
+
+  fmt.format = last_format;
+  fmt.size = last_size;
+  fmt.count = 1;
+
+  if (exp && *exp == '/')
+    {
+      exp++;
+      fmt = decode_format (&exp, last_format, last_size);
+    }
+
+  /* If we have an expression, evaluate it and use it as the address.  */
+
+  if (exp != 0 && *exp != 0)
+    {
+      expr = parse_expression (exp);
+      /* Cause expression not to be there any more
+         if this command is repeated with Newline.
+         But don't clobber a user-defined command's definition.  */
+      if (from_tty)
+	*exp = 0;
+      old_chain = make_cleanup (free_current_contents, &expr);
+      val = evaluate_expression (expr);
+      if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF)
+	val = value_ind (val);
+      /* In rvalue contexts, such as this, functions are coerced into
+         pointers to functions.  This makes "x/i main" work.  */
+      if (/* last_format == 'i'  && */ 
+	  TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
+	   && VALUE_LVAL (val) == lval_memory)
+	next_address = VALUE_ADDRESS (val);
+      else
+	next_address = value_as_address (val);
+      if (VALUE_BFD_SECTION (val))
+	next_section = VALUE_BFD_SECTION (val);
+      do_cleanups (old_chain);
+    }
+
+  do_examine (fmt, next_address, next_section);
+
+  /* If the examine succeeds, we remember its size and format for next time.  */
+  last_size = fmt.size;
+  last_format = fmt.format;
+
+  /* Set a couple of internal variables if appropriate. */
+  if (last_examine_value)
+    {
+      /* Make last address examined available to the user as $_.  Use
+         the correct pointer type.  */
+      struct type *pointer_type
+	= lookup_pointer_type (VALUE_TYPE (last_examine_value));
+      set_internalvar (lookup_internalvar ("_"),
+		       value_from_pointer (pointer_type,
+					   last_examine_address));
+
+      /* Make contents of last address examined available to the user as $__. */
+      /* If the last value has not been fetched from memory then don't
+         fetch it now - instead mark it by voiding the $__ variable. */
+      if (VALUE_LAZY (last_examine_value))
+	set_internalvar (lookup_internalvar ("__"),
+			 allocate_value (builtin_type_void));
+      else
+	set_internalvar (lookup_internalvar ("__"), last_examine_value);
+    }
+}
+
+
+/* Add an expression to the auto-display chain.
+   Specify the expression.  */
+
+static void
+display_command (char *exp, int from_tty)
+{
+  struct format_data fmt;
+  register struct expression *expr;
+  register struct display *new;
+  int display_it = 1;
+
+#if defined(TUI)
+  if (tui_version && *exp == '$')
+    display_it = (tui_set_layout (exp) == TUI_FAILURE);
+#endif
+
+  if (display_it)
+    {
+      if (exp == 0)
+	{
+	  do_displays ();
+	  return;
+	}
+
+      if (*exp == '/')
+	{
+	  exp++;
+	  fmt = decode_format (&exp, 0, 0);
+	  if (fmt.size && fmt.format == 0)
+	    fmt.format = 'x';
+	  if (fmt.format == 'i' || fmt.format == 's')
+	    fmt.size = 'b';
+	}
+      else
+	{
+	  fmt.format = 0;
+	  fmt.size = 0;
+	  fmt.count = 0;
+	}
+
+      innermost_block = 0;
+      expr = parse_expression (exp);
+
+      new = (struct display *) xmalloc (sizeof (struct display));
+
+      new->exp = expr;
+      new->block = innermost_block;
+      new->next = display_chain;
+      new->number = ++display_number;
+      new->format = fmt;
+      new->enabled_p = 1;
+      display_chain = new;
+
+      if (from_tty && target_has_execution)
+	do_one_display (new);
+
+      dont_repeat ();
+    }
+}
+
+static void
+free_display (struct display *d)
+{
+  xfree (d->exp);
+  xfree (d);
+}
+
+/* Clear out the display_chain.
+   Done when new symtabs are loaded, since this invalidates
+   the types stored in many expressions.  */
+
+void
+clear_displays (void)
+{
+  register struct display *d;
+
+  while ((d = display_chain) != NULL)
+    {
+      xfree (d->exp);
+      display_chain = d->next;
+      xfree (d);
+    }
+}
+
+/* Delete the auto-display number NUM.  */
+
+static void
+delete_display (int num)
+{
+  register struct display *d1, *d;
+
+  if (!display_chain)
+    error ("No display number %d.", num);
+
+  if (display_chain->number == num)
+    {
+      d1 = display_chain;
+      display_chain = d1->next;
+      free_display (d1);
+    }
+  else
+    for (d = display_chain;; d = d->next)
+      {
+	if (d->next == 0)
+	  error ("No display number %d.", num);
+	if (d->next->number == num)
+	  {
+	    d1 = d->next;
+	    d->next = d1->next;
+	    free_display (d1);
+	    break;
+	  }
+      }
+}
+
+/* Delete some values from the auto-display chain.
+   Specify the element numbers.  */
+
+static void
+undisplay_command (char *args, int from_tty)
+{
+  register char *p = args;
+  register char *p1;
+  register int num;
+
+  if (args == 0)
+    {
+      if (query ("Delete all auto-display expressions? "))
+	clear_displays ();
+      dont_repeat ();
+      return;
+    }
+
+  while (*p)
+    {
+      p1 = p;
+      while (*p1 >= '0' && *p1 <= '9')
+	p1++;
+      if (*p1 && *p1 != ' ' && *p1 != '\t')
+	error ("Arguments must be display numbers.");
+
+      num = atoi (p);
+
+      delete_display (num);
+
+      p = p1;
+      while (*p == ' ' || *p == '\t')
+	p++;
+    }
+  dont_repeat ();
+}
+
+/* Display a single auto-display.  
+   Do nothing if the display cannot be printed in the current context,
+   or if the display is disabled. */
+
+static void
+do_one_display (struct display *d)
+{
+  int within_current_scope;
+
+  if (d->enabled_p == 0)
+    return;
+
+  if (d->block)
+    within_current_scope = contained_in (get_selected_block (0), d->block);
+  else
+    within_current_scope = 1;
+  if (!within_current_scope)
+    return;
+
+  current_display_number = d->number;
+
+  annotate_display_begin ();
+  printf_filtered ("%d", d->number);
+  annotate_display_number_end ();
+  printf_filtered (": ");
+  if (d->format.size)
+    {
+      CORE_ADDR addr;
+      struct value *val;
+
+      annotate_display_format ();
+
+      printf_filtered ("x/");
+      if (d->format.count != 1)
+	printf_filtered ("%d", d->format.count);
+      printf_filtered ("%c", d->format.format);
+      if (d->format.format != 'i' && d->format.format != 's')
+	printf_filtered ("%c", d->format.size);
+      printf_filtered (" ");
+
+      annotate_display_expression ();
+
+      print_expression (d->exp, gdb_stdout);
+      annotate_display_expression_end ();
+
+      if (d->format.count != 1)
+	printf_filtered ("\n");
+      else
+	printf_filtered ("  ");
+
+      val = evaluate_expression (d->exp);
+      addr = value_as_address (val);
+      if (d->format.format == 'i')
+	addr = ADDR_BITS_REMOVE (addr);
+
+      annotate_display_value ();
+
+      do_examine (d->format, addr, VALUE_BFD_SECTION (val));
+    }
+  else
+    {
+      annotate_display_format ();
+
+      if (d->format.format)
+	printf_filtered ("/%c ", d->format.format);
+
+      annotate_display_expression ();
+
+      print_expression (d->exp, gdb_stdout);
+      annotate_display_expression_end ();
+
+      printf_filtered (" = ");
+
+      annotate_display_expression ();
+
+      print_formatted (evaluate_expression (d->exp),
+		       d->format.format, d->format.size, gdb_stdout);
+      printf_filtered ("\n");
+    }
+
+  annotate_display_end ();
+
+  gdb_flush (gdb_stdout);
+  current_display_number = -1;
+}
+
+/* Display all of the values on the auto-display chain which can be
+   evaluated in the current scope.  */
+
+void
+do_displays (void)
+{
+  register struct display *d;
+
+  for (d = display_chain; d; d = d->next)
+    do_one_display (d);
+}
+
+/* Delete the auto-display which we were in the process of displaying.
+   This is done when there is an error or a signal.  */
+
+void
+disable_display (int num)
+{
+  register struct display *d;
+
+  for (d = display_chain; d; d = d->next)
+    if (d->number == num)
+      {
+	d->enabled_p = 0;
+	return;
+      }
+  printf_unfiltered ("No display number %d.\n", num);
+}
+
+void
+disable_current_display (void)
+{
+  if (current_display_number >= 0)
+    {
+      disable_display (current_display_number);
+      fprintf_unfiltered (gdb_stderr, "Disabling display %d to avoid infinite recursion.\n",
+			  current_display_number);
+    }
+  current_display_number = -1;
+}
+
+static void
+display_info (char *ignore, int from_tty)
+{
+  register struct display *d;
+
+  if (!display_chain)
+    printf_unfiltered ("There are no auto-display expressions now.\n");
+  else
+    printf_filtered ("Auto-display expressions now in effect:\n\
+Num Enb Expression\n");
+
+  for (d = display_chain; d; d = d->next)
+    {
+      printf_filtered ("%d:   %c  ", d->number, "ny"[(int) d->enabled_p]);
+      if (d->format.size)
+	printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
+			 d->format.format);
+      else if (d->format.format)
+	printf_filtered ("/%c ", d->format.format);
+      print_expression (d->exp, gdb_stdout);
+      if (d->block && !contained_in (get_selected_block (0), d->block))
+	printf_filtered (" (cannot be evaluated in the current context)");
+      printf_filtered ("\n");
+      gdb_flush (gdb_stdout);
+    }
+}
+
+static void
+enable_display (char *args, int from_tty)
+{
+  register char *p = args;
+  register char *p1;
+  register int num;
+  register struct display *d;
+
+  if (p == 0)
+    {
+      for (d = display_chain; d; d = d->next)
+	d->enabled_p = 1;
+    }
+  else
+    while (*p)
+      {
+	p1 = p;
+	while (*p1 >= '0' && *p1 <= '9')
+	  p1++;
+	if (*p1 && *p1 != ' ' && *p1 != '\t')
+	  error ("Arguments must be display numbers.");
+
+	num = atoi (p);
+
+	for (d = display_chain; d; d = d->next)
+	  if (d->number == num)
+	    {
+	      d->enabled_p = 1;
+	      goto win;
+	    }
+	printf_unfiltered ("No display number %d.\n", num);
+      win:
+	p = p1;
+	while (*p == ' ' || *p == '\t')
+	  p++;
+      }
+}
+
+/* ARGSUSED */
+static void
+disable_display_command (char *args, int from_tty)
+{
+  register char *p = args;
+  register char *p1;
+  register struct display *d;
+
+  if (p == 0)
+    {
+      for (d = display_chain; d; d = d->next)
+	d->enabled_p = 0;
+    }
+  else
+    while (*p)
+      {
+	p1 = p;
+	while (*p1 >= '0' && *p1 <= '9')
+	  p1++;
+	if (*p1 && *p1 != ' ' && *p1 != '\t')
+	  error ("Arguments must be display numbers.");
+
+	disable_display (atoi (p));
+
+	p = p1;
+	while (*p == ' ' || *p == '\t')
+	  p++;
+      }
+}
+
+
+/* Print the value in stack frame FRAME of a variable
+   specified by a struct symbol.  */
+
+void
+print_variable_value (struct symbol *var, struct frame_info *frame,
+		      struct ui_file *stream)
+{
+  struct value *val = read_var_value (var, frame);
+
+  value_print (val, stream, 0, Val_pretty_default);
+}
+
+/* Print the arguments of a stack frame, given the function FUNC
+   running in that frame (as a symbol), the info on the frame,
+   and the number of args according to the stack frame (or -1 if unknown).  */
+
+/* References here and elsewhere to "number of args according to the
+   stack frame" appear in all cases to refer to "number of ints of args
+   according to the stack frame".  At least for VAX, i386, isi.  */
+
+void
+print_frame_args (struct symbol *func, struct frame_info *fi, int num,
+		  struct ui_file *stream)
+{
+  struct block *b = NULL;
+  int first = 1;
+  register int i;
+  register struct symbol *sym;
+  struct value *val;
+  /* Offset of next stack argument beyond the one we have seen that is
+     at the highest offset.
+     -1 if we haven't come to a stack argument yet.  */
+  long highest_offset = -1;
+  int arg_size;
+  /* Number of ints of arguments that we have printed so far.  */
+  int args_printed = 0;
+  struct cleanup *old_chain, *list_chain;
+  struct ui_stream *stb;
+
+  stb = ui_out_stream_new (uiout);
+  old_chain = make_cleanup_ui_out_stream_delete (stb);
+
+  if (func)
+    {
+      b = SYMBOL_BLOCK_VALUE (func);
+      /* Function blocks are order sensitive, and thus should not be
+	 hashed.  */
+      gdb_assert (BLOCK_HASHTABLE (b) == 0);
+
+      ALL_BLOCK_SYMBOLS (b, i, sym)
+        {
+	  QUIT;
+
+	  /* Keep track of the highest stack argument offset seen, and
+	     skip over any kinds of symbols we don't care about.  */
+
+	  switch (SYMBOL_CLASS (sym))
+	    {
+	    case LOC_ARG:
+	    case LOC_REF_ARG:
+	      {
+		long current_offset = SYMBOL_VALUE (sym);
+		arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
+
+		/* Compute address of next argument by adding the size of
+		   this argument and rounding to an int boundary.  */
+		current_offset =
+		  ((current_offset + arg_size + sizeof (int) - 1)
+		   & ~(sizeof (int) - 1));
+
+		/* If this is the highest offset seen yet, set highest_offset.  */
+		if (highest_offset == -1
+		    || (current_offset > highest_offset))
+		  highest_offset = current_offset;
+
+		/* Add the number of ints we're about to print to args_printed.  */
+		args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
+	      }
+
+	      /* We care about types of symbols, but don't need to keep track of
+		 stack offsets in them.  */
+	    case LOC_REGPARM:
+	    case LOC_REGPARM_ADDR:
+	    case LOC_LOCAL_ARG:
+	    case LOC_BASEREG_ARG:
+	      break;
+
+	    /* Other types of symbols we just skip over.  */
+	    default:
+	      continue;
+	    }
+
+	  /* We have to look up the symbol because arguments can have
+	     two entries (one a parameter, one a local) and the one we
+	     want is the local, which lookup_symbol will find for us.
+	     This includes gcc1 (not gcc2) on the sparc when passing a
+	     small structure and gcc2 when the argument type is float
+	     and it is passed as a double and converted to float by
+	     the prologue (in the latter case the type of the LOC_ARG
+	     symbol is double and the type of the LOC_LOCAL symbol is
+	     float).  */
+	  /* But if the parameter name is null, don't try it.
+	     Null parameter names occur on the RS/6000, for traceback tables.
+	     FIXME, should we even print them?  */
+
+	  if (*SYMBOL_NAME (sym))
+	    {
+	      struct symbol *nsym;
+	      nsym = lookup_symbol
+		(SYMBOL_NAME (sym),
+		 b, VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
+	      if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
+		{
+		  /* There is a LOC_ARG/LOC_REGISTER pair.  This means that
+		     it was passed on the stack and loaded into a register,
+		     or passed in a register and stored in a stack slot.
+		     GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
+
+		     Reasons for using the LOC_ARG:
+		     (1) because find_saved_registers may be slow for remote
+		     debugging,
+		     (2) because registers are often re-used and stack slots
+		     rarely (never?) are.  Therefore using the stack slot is
+		     much less likely to print garbage.
+
+		     Reasons why we might want to use the LOC_REGISTER:
+		     (1) So that the backtrace prints the same value as
+		     "print foo".  I see no compelling reason why this needs
+		     to be the case; having the backtrace print the value which
+		     was passed in, and "print foo" print the value as modified
+		     within the called function, makes perfect sense to me.
+
+		     Additional note:  It might be nice if "info args" displayed
+		     both values.
+		     One more note:  There is a case with sparc structure passing
+		     where we need to use the LOC_REGISTER, but this is dealt with
+		     by creating a single LOC_REGPARM in symbol reading.  */
+
+		  /* Leave sym (the LOC_ARG) alone.  */
+		  ;
+		}
+	      else
+		sym = nsym;
+	    }
+
+	  /* Print the current arg.  */
+	  if (!first)
+	    ui_out_text (uiout, ", ");
+	  ui_out_wrap_hint (uiout, "    ");
+
+	  annotate_arg_begin ();
+
+	  list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+	  fprintf_symbol_filtered (stb->stream, SYMBOL_SOURCE_NAME (sym),
+				   SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
+	  ui_out_field_stream (uiout, "name", stb);
+	  annotate_arg_name_end ();
+	  ui_out_text (uiout, "=");
+
+	  /* Avoid value_print because it will deref ref parameters.  We just
+	     want to print their addresses.  Print ??? for args whose address
+	     we do not know.  We pass 2 as "recurse" to val_print because our
+	     standard indentation here is 4 spaces, and val_print indents
+	     2 for each recurse.  */
+	  val = read_var_value (sym, fi);
+
+	  annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val));
+
+	  if (val)
+	    {
+	      val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
+			 VALUE_ADDRESS (val),
+			 stb->stream, 0, 0, 2, Val_no_prettyprint);
+	      ui_out_field_stream (uiout, "value", stb);
+	    }
+	  else
+	    ui_out_text (uiout, "???");
+
+	  /* Invoke ui_out_tuple_end.  */
+	  do_cleanups (list_chain);
+
+	  annotate_arg_end ();
+
+	  first = 0;
+	}
+    }
+
+  /* Don't print nameless args in situations where we don't know
+     enough about the stack to find them.  */
+  if (num != -1)
+    {
+      long start;
+
+      if (highest_offset == -1)
+	start = FRAME_ARGS_SKIP;
+      else
+	start = highest_offset;
+
+      print_frame_nameless_args (fi, start, num - args_printed,
+				 first, stream);
+    }
+  do_cleanups (old_chain);
+}
+
+/* Print nameless args on STREAM.
+   FI is the frameinfo for this frame, START is the offset
+   of the first nameless arg, and NUM is the number of nameless args to
+   print.  FIRST is nonzero if this is the first argument (not just
+   the first nameless arg).  */
+
+static void
+print_frame_nameless_args (struct frame_info *fi, long start, int num,
+			   int first, struct ui_file *stream)
+{
+  int i;
+  CORE_ADDR argsaddr;
+  long arg_value;
+
+  for (i = 0; i < num; i++)
+    {
+      QUIT;
+#ifdef NAMELESS_ARG_VALUE
+      NAMELESS_ARG_VALUE (fi, start, &arg_value);
+#else
+      argsaddr = FRAME_ARGS_ADDRESS (fi);
+      if (!argsaddr)
+	return;
+
+      arg_value = read_memory_integer (argsaddr + start, sizeof (int));
+#endif
+
+      if (!first)
+	fprintf_filtered (stream, ", ");
+
+#ifdef	PRINT_NAMELESS_INTEGER
+      PRINT_NAMELESS_INTEGER (stream, arg_value);
+#else
+#ifdef PRINT_TYPELESS_INTEGER
+      PRINT_TYPELESS_INTEGER (stream, builtin_type_int, (LONGEST) arg_value);
+#else
+      fprintf_filtered (stream, "%ld", arg_value);
+#endif /* PRINT_TYPELESS_INTEGER */
+#endif /* PRINT_NAMELESS_INTEGER */
+      first = 0;
+      start += sizeof (int);
+    }
+}
+
+/* ARGSUSED */
+static void
+printf_command (char *arg, int from_tty)
+{
+  register char *f = NULL;
+  register char *s = arg;
+  char *string = NULL;
+  struct value **val_args;
+  char *substrings;
+  char *current_substring;
+  int nargs = 0;
+  int allocated_args = 20;
+  struct cleanup *old_cleanups;
+
+  val_args = (struct value **) xmalloc (allocated_args
+					* sizeof (struct value *));
+  old_cleanups = make_cleanup (free_current_contents, &val_args);
+
+  if (s == 0)
+    error_no_arg ("format-control string and values to print");
+
+  /* Skip white space before format string */
+  while (*s == ' ' || *s == '\t')
+    s++;
+
+  /* A format string should follow, enveloped in double quotes */
+  if (*s++ != '"')
+    error ("Bad format string, missing '\"'.");
+
+  /* Parse the format-control string and copy it into the string STRING,
+     processing some kinds of escape sequence.  */
+
+  f = string = (char *) alloca (strlen (s) + 1);
+
+  while (*s != '"')
+    {
+      int c = *s++;
+      switch (c)
+	{
+	case '\0':
+	  error ("Bad format string, non-terminated '\"'.");
+
+	case '\\':
+	  switch (c = *s++)
+	    {
+	    case '\\':
+	      *f++ = '\\';
+	      break;
+	    case 'a':
+	      *f++ = '\a';
+	      break;
+	    case 'b':
+	      *f++ = '\b';
+	      break;
+	    case 'f':
+	      *f++ = '\f';
+	      break;
+	    case 'n':
+	      *f++ = '\n';
+	      break;
+	    case 'r':
+	      *f++ = '\r';
+	      break;
+	    case 't':
+	      *f++ = '\t';
+	      break;
+	    case 'v':
+	      *f++ = '\v';
+	      break;
+	    case '"':
+	      *f++ = '"';
+	      break;
+	    default:
+	      /* ??? TODO: handle other escape sequences */
+	      error ("Unrecognized escape character \\%c in format string.",
+		     c);
+	    }
+	  break;
+
+	default:
+	  *f++ = c;
+	}
+    }
+
+  /* Skip over " and following space and comma.  */
+  s++;
+  *f++ = '\0';
+  while (*s == ' ' || *s == '\t')
+    s++;
+
+  if (*s != ',' && *s != 0)
+    error ("Invalid argument syntax");
+
+  if (*s == ',')
+    s++;
+  while (*s == ' ' || *s == '\t')
+    s++;
+
+  /* Need extra space for the '\0's.  Doubling the size is sufficient.  */
+  substrings = alloca (strlen (string) * 2);
+  current_substring = substrings;
+
+  {
+    /* Now scan the string for %-specs and see what kinds of args they want.
+       argclass[I] classifies the %-specs so we can give printf_filtered
+       something of the right size.  */
+
+    enum argclass
+      {
+	no_arg, int_arg, string_arg, double_arg, long_long_arg
+      };
+    enum argclass *argclass;
+    enum argclass this_argclass;
+    char *last_arg;
+    int nargs_wanted;
+    int lcount;
+    int i;
+
+    argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
+    nargs_wanted = 0;
+    f = string;
+    last_arg = string;
+    while (*f)
+      if (*f++ == '%')
+	{
+	  lcount = 0;
+	  while (strchr ("0123456789.hlL-+ #", *f))
+	    {
+	      if (*f == 'l' || *f == 'L')
+		lcount++;
+	      f++;
+	    }
+	  switch (*f)
+	    {
+	    case 's':
+	      this_argclass = string_arg;
+	      break;
+
+	    case 'e':
+	    case 'f':
+	    case 'g':
+	      this_argclass = double_arg;
+	      break;
+
+	    case '*':
+	      error ("`*' not supported for precision or width in printf");
+
+	    case 'n':
+	      error ("Format specifier `n' not supported in printf");
+
+	    case '%':
+	      this_argclass = no_arg;
+	      break;
+
+	    default:
+	      if (lcount > 1)
+		this_argclass = long_long_arg;
+	      else
+		this_argclass = int_arg;
+	      break;
+	    }
+	  f++;
+	  if (this_argclass != no_arg)
+	    {
+	      strncpy (current_substring, last_arg, f - last_arg);
+	      current_substring += f - last_arg;
+	      *current_substring++ = '\0';
+	      last_arg = f;
+	      argclass[nargs_wanted++] = this_argclass;
+	    }
+	}
+
+    /* Now, parse all arguments and evaluate them.
+       Store the VALUEs in VAL_ARGS.  */
+
+    while (*s != '\0')
+      {
+	char *s1;
+	if (nargs == allocated_args)
+	  val_args = (struct value **) xrealloc ((char *) val_args,
+						 (allocated_args *= 2)
+						 * sizeof (struct value *));
+	s1 = s;
+	val_args[nargs] = parse_to_comma_and_eval (&s1);
+
+	/* If format string wants a float, unchecked-convert the value to
+	   floating point of the same size */
+
+	if (argclass[nargs] == double_arg)
+	  {
+	    struct type *type = VALUE_TYPE (val_args[nargs]);
+	    if (TYPE_LENGTH (type) == sizeof (float))
+	        VALUE_TYPE (val_args[nargs]) = builtin_type_float;
+	    if (TYPE_LENGTH (type) == sizeof (double))
+	        VALUE_TYPE (val_args[nargs]) = builtin_type_double;
+	  }
+	nargs++;
+	s = s1;
+	if (*s == ',')
+	  s++;
+      }
+
+    if (nargs != nargs_wanted)
+      error ("Wrong number of arguments for specified format-string");
+
+    /* Now actually print them.  */
+    current_substring = substrings;
+    for (i = 0; i < nargs; i++)
+      {
+	switch (argclass[i])
+	  {
+	  case string_arg:
+	    {
+	      char *str;
+	      CORE_ADDR tem;
+	      int j;
+	      tem = value_as_address (val_args[i]);
+
+	      /* This is a %s argument.  Find the length of the string.  */
+	      for (j = 0;; j++)
+		{
+		  char c;
+		  QUIT;
+		  read_memory (tem + j, &c, 1);
+		  if (c == 0)
+		    break;
+		}
+
+	      /* Copy the string contents into a string inside GDB.  */
+	      str = (char *) alloca (j + 1);
+	      if (j != 0)
+		read_memory (tem, str, j);
+	      str[j] = 0;
+
+	      printf_filtered (current_substring, str);
+	    }
+	    break;
+	  case double_arg:
+	    {
+	      double val = value_as_double (val_args[i]);
+	      printf_filtered (current_substring, val);
+	      break;
+	    }
+	  case long_long_arg:
+#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
+	    {
+	      long long val = value_as_long (val_args[i]);
+	      printf_filtered (current_substring, val);
+	      break;
+	    }
+#else
+	    error ("long long not supported in printf");
+#endif
+	  case int_arg:
+	    {
+	      /* FIXME: there should be separate int_arg and long_arg.  */
+	      long val = value_as_long (val_args[i]);
+	      printf_filtered (current_substring, val);
+	      break;
+	    }
+	  default:		/* purecov: deadcode */
+	    error ("internal error in printf_command");		/* purecov: deadcode */
+	  }
+	/* Skip to the next substring.  */
+	current_substring += strlen (current_substring) + 1;
+      }
+    /* Print the portion of the format string after the last argument.  */
+    printf_filtered (last_arg);
+  }
+  do_cleanups (old_cleanups);
+}
+
+/* Dump a specified section of assembly code.  With no command line
+   arguments, this command will dump the assembly code for the
+   function surrounding the pc value in the selected frame.  With one
+   argument, it will dump the assembly code surrounding that pc value.
+   Two arguments are interpeted as bounds within which to dump
+   assembly.  */
+
+/* ARGSUSED */
+static void
+disassemble_command (char *arg, int from_tty)
+{
+  CORE_ADDR low, high;
+  char *name;
+  CORE_ADDR pc, pc_masked;
+  char *space_index;
+#if 0
+  asection *section;
+#endif
+
+  name = NULL;
+  if (!arg)
+    {
+      if (!selected_frame)
+	error ("No frame selected.\n");
+
+      pc = get_frame_pc (selected_frame);
+      if (find_pc_partial_function (pc, &name, &low, &high) == 0)
+	error ("No function contains program counter for selected frame.\n");
+#if defined(TUI)
+      else if (tui_version)
+	low = tuiGetLowDisassemblyAddress (low, pc);
+#endif
+      low += FUNCTION_START_OFFSET;
+    }
+  else if (!(space_index = (char *) strchr (arg, ' ')))
+    {
+      /* One argument.  */
+      pc = parse_and_eval_address (arg);
+      if (find_pc_partial_function (pc, &name, &low, &high) == 0)
+	error ("No function contains specified address.\n");
+#if defined(TUI)
+      else if (tui_version)
+	low = tuiGetLowDisassemblyAddress (low, pc);
+#endif
+      low += FUNCTION_START_OFFSET;
+    }
+  else
+    {
+      /* Two arguments.  */
+      *space_index = '\0';
+      low = parse_and_eval_address (arg);
+      high = parse_and_eval_address (space_index + 1);
+    }
+
+#if defined(TUI)
+  if (!tui_is_window_visible (DISASSEM_WIN))
+#endif
+    {
+      printf_filtered ("Dump of assembler code ");
+      if (name != NULL)
+	{
+	  printf_filtered ("for function %s:\n", name);
+	}
+      else
+	{
+	  printf_filtered ("from ");
+	  print_address_numeric (low, 1, gdb_stdout);
+	  printf_filtered (" to ");
+	  print_address_numeric (high, 1, gdb_stdout);
+	  printf_filtered (":\n");
+	}
+
+      /* Dump the specified range.  */
+      pc = low;
+
+#ifdef GDB_TARGET_MASK_DISAS_PC
+      pc_masked = GDB_TARGET_MASK_DISAS_PC (pc);
+#else
+      pc_masked = pc;
+#endif
+
+      while (pc_masked < high)
+	{
+	  QUIT;
+	  print_address (pc_masked, gdb_stdout);
+	  printf_filtered (":\t");
+	  /* We often wrap here if there are long symbolic names.  */
+	  wrap_here ("    ");
+	  pc += print_insn (pc, gdb_stdout);
+	  printf_filtered ("\n");
+
+#ifdef GDB_TARGET_MASK_DISAS_PC
+	  pc_masked = GDB_TARGET_MASK_DISAS_PC (pc);
+#else
+	  pc_masked = pc;
+#endif
+	}
+      printf_filtered ("End of assembler dump.\n");
+      gdb_flush (gdb_stdout);
+    }
+#if defined(TUI)
+  else
+    {
+      tui_show_assembly (low);
+    }
+#endif
+}
+
+/* Print the instruction at address MEMADDR in debugged memory,
+   on STREAM.  Returns length of the instruction, in bytes.  */
+
+static int
+print_insn (CORE_ADDR memaddr, struct ui_file *stream)
+{
+  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+    TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_BIG;
+  else
+    TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_LITTLE;
+
+  if (TARGET_ARCHITECTURE != NULL)
+    TARGET_PRINT_INSN_INFO->mach = TARGET_ARCHITECTURE->mach;
+  /* else: should set .mach=0 but some disassemblers don't grok this */
+
+  TARGET_PRINT_INSN_INFO->stream = stream;
+
+  return TARGET_PRINT_INSN (memaddr, TARGET_PRINT_INSN_INFO);
+}
+
+
+void
+_initialize_printcmd (void)
+{
+  struct cmd_list_element *c;
+
+  current_display_number = -1;
+
+  add_info ("address", address_info,
+	    "Describe where symbol SYM is stored.");
+
+  add_info ("symbol", sym_info,
+	    "Describe what symbol is at location ADDR.\n\
+Only for symbols with fixed locations (global or static scope).");
+
+  add_com ("x", class_vars, x_command,
+	   concat ("Examine memory: x/FMT ADDRESS.\n\
+ADDRESS is an expression for the memory address to examine.\n\
+FMT is a repeat count followed by a format letter and a size letter.\n\
+Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
+  t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n",
+		   "Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
+The specified number of objects of the specified size are printed\n\
+according to the format.\n\n\
+Defaults for format and size letters are those previously used.\n\
+Default count is 1.  Default address is following last thing printed\n\
+with this command or \"print\".", NULL));
+
+  c = add_com ("disassemble", class_vars, disassemble_command,
+	       "Disassemble a specified section of memory.\n\
+Default is the function surrounding the pc of the selected frame.\n\
+With a single argument, the function surrounding that address is dumped.\n\
+Two arguments are taken as a range of memory to dump.");
+  set_cmd_completer (c, location_completer);
+  if (xdb_commands)
+    add_com_alias ("va", "disassemble", class_xdb, 0);
+
+#if 0
+  add_com ("whereis", class_vars, whereis_command,
+	   "Print line number and file of definition of variable.");
+#endif
+
+  add_info ("display", display_info,
+	    "Expressions to display when program stops, with code numbers.");
+
+  add_cmd ("undisplay", class_vars, undisplay_command,
+	   "Cancel some expressions to be displayed when program stops.\n\
+Arguments are the code numbers of the expressions to stop displaying.\n\
+No argument means cancel all automatic-display expressions.\n\
+\"delete display\" has the same effect as this command.\n\
+Do \"info display\" to see current list of code numbers.",
+	   &cmdlist);
+
+  add_com ("display", class_vars, display_command,
+	   "Print value of expression EXP each time the program stops.\n\
+/FMT may be used before EXP as in the \"print\" command.\n\
+/FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
+as in the \"x\" command, and then EXP is used to get the address to examine\n\
+and examining is done as in the \"x\" command.\n\n\
+With no argument, display all currently requested auto-display expressions.\n\
+Use \"undisplay\" to cancel display requests previously made."
+    );
+
+  add_cmd ("display", class_vars, enable_display,
+	   "Enable some expressions to be displayed when program stops.\n\
+Arguments are the code numbers of the expressions to resume displaying.\n\
+No argument means enable all automatic-display expressions.\n\
+Do \"info display\" to see current list of code numbers.", &enablelist);
+
+  add_cmd ("display", class_vars, disable_display_command,
+	   "Disable some expressions to be displayed when program stops.\n\
+Arguments are the code numbers of the expressions to stop displaying.\n\
+No argument means disable all automatic-display expressions.\n\
+Do \"info display\" to see current list of code numbers.", &disablelist);
+
+  add_cmd ("display", class_vars, undisplay_command,
+	   "Cancel some expressions to be displayed when program stops.\n\
+Arguments are the code numbers of the expressions to stop displaying.\n\
+No argument means cancel all automatic-display expressions.\n\
+Do \"info display\" to see current list of code numbers.", &deletelist);
+
+  add_com ("printf", class_vars, printf_command,
+	   "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
+This is useful for formatted output in user-defined commands.");
+
+  add_com ("output", class_vars, output_command,
+	   "Like \"print\" but don't put in value history and don't print newline.\n\
+This is useful in user-defined commands.");
+
+  add_prefix_cmd ("set", class_vars, set_command,
+		  concat ("Evaluate expression EXP and assign result to variable VAR, using assignment\n\
+syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
+example).  VAR may be a debugger \"convenience\" variable (names starting\n\
+with $), a register (a few standard names starting with $), or an actual\n\
+variable in the program being debugged.  EXP is any valid expression.\n",
+			  "Use \"set variable\" for variables with names identical to set subcommands.\n\
+\nWith a subcommand, this command modifies parts of the gdb environment.\n\
+You can see these environment settings with the \"show\" command.", NULL),
+		  &setlist, "set ", 1, &cmdlist);
+  if (dbx_commands)
+    add_com ("assign", class_vars, set_command, concat ("Evaluate expression \
+EXP and assign result to variable VAR, using assignment\n\
+syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
+example).  VAR may be a debugger \"convenience\" variable (names starting\n\
+with $), a register (a few standard names starting with $), or an actual\n\
+variable in the program being debugged.  EXP is any valid expression.\n",
+							"Use \"set variable\" for variables with names identical to set subcommands.\n\
+\nWith a subcommand, this command modifies parts of the gdb environment.\n\
+You can see these environment settings with the \"show\" command.", NULL));
+
+  /* "call" is the same as "set", but handy for dbx users to call fns. */
+  c = add_com ("call", class_vars, call_command,
+	       "Call a function in the program.\n\
+The argument is the function name and arguments, in the notation of the\n\
+current working language.  The result is printed and saved in the value\n\
+history, if it is not void.");
+  set_cmd_completer (c, location_completer);
+
+  add_cmd ("variable", class_vars, set_command,
+	   "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
+syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
+example).  VAR may be a debugger \"convenience\" variable (names starting\n\
+with $), a register (a few standard names starting with $), or an actual\n\
+variable in the program being debugged.  EXP is any valid expression.\n\
+This may usually be abbreviated to simply \"set\".",
+	   &setlist);
+
+  c = add_com ("print", class_vars, print_command,
+	   concat ("Print value of expression EXP.\n\
+Variables accessible are those of the lexical environment of the selected\n\
+stack frame, plus all those whose scope is global or an entire file.\n\
+\n\
+$NUM gets previous value number NUM.  $ and $$ are the last two values.\n\
+$$NUM refers to NUM'th value back from the last one.\n\
+Names starting with $ refer to registers (with the values they would have\n",
+		   "if the program were to return to the stack frame now selected, restoring\n\
+all registers saved by frames farther in) or else to debugger\n\
+\"convenience\" variables (any such name not a known register).\n\
+Use assignment expressions to give values to convenience variables.\n",
+		   "\n\
+{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
+@ is a binary operator for treating consecutive data objects\n\
+anywhere in memory as an array.  FOO@NUM gives an array whose first\n\
+element is FOO, whose second element is stored in the space following\n\
+where FOO is stored, etc.  FOO must be an expression whose value\n\
+resides in memory.\n",
+		   "\n\
+EXP may be preceded with /FMT, where FMT is a format letter\n\
+but no count or size letter (see \"x\" command).", NULL));
+  set_cmd_completer (c, location_completer);
+  add_com_alias ("p", "print", class_vars, 1);
+
+  c = add_com ("inspect", class_vars, inspect_command,
+	   "Same as \"print\" command, except that if you are running in the epoch\n\
+environment, the value is printed in its own window.");
+  set_cmd_completer (c, location_completer);
+
+  add_show_from_set (
+		 add_set_cmd ("max-symbolic-offset", no_class, var_uinteger,
+			      (char *) &max_symbolic_offset,
+       "Set the largest offset that will be printed in <symbol+1234> form.",
+			      &setprintlist),
+		      &showprintlist);
+  add_show_from_set (
+		      add_set_cmd ("symbol-filename", no_class, var_boolean,
+				   (char *) &print_symbol_filename,
+	   "Set printing of source filename and line number with <symbol>.",
+				   &setprintlist),
+		      &showprintlist);
+
+  /* For examine/instruction a single byte quantity is specified as
+     the data.  This avoids problems with value_at_lazy() requiring a
+     valid data type (and rejecting VOID). */
+  examine_i_type = init_type (TYPE_CODE_INT, 1, 0, "examine_i_type", NULL);
+
+  examine_b_type = init_type (TYPE_CODE_INT, 1, 0, "examine_b_type", NULL);
+  examine_h_type = init_type (TYPE_CODE_INT, 2, 0, "examine_h_type", NULL);
+  examine_w_type = init_type (TYPE_CODE_INT, 4, 0, "examine_w_type", NULL);
+  examine_g_type = init_type (TYPE_CODE_INT, 8, 0, "examine_g_type", NULL);
+
+}
diff --git a/gdb/stack.c b/gdb/stack.c
new file mode 100644
index 0000000..4f41531
--- /dev/null
+++ b/gdb/stack.c
@@ -0,0 +1,2023 @@
+/* Print and select stack frames for GDB, the GNU debugger.
+
+   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
+   Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <ctype.h>
+#include "defs.h"
+#include "gdb_string.h"
+#include "value.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "expression.h"
+#include "language.h"
+#include "frame.h"
+#include "gdbcmd.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "source.h"
+#include "breakpoint.h"
+#include "demangle.h"
+#include "inferior.h"
+#include "annotate.h"
+#include "ui-out.h"
+
+/* Prototypes for exported functions. */
+
+void args_info (char *, int);
+
+void locals_info (char *, int);
+
+void (*selected_frame_level_changed_hook) (int);
+
+void _initialize_stack (void);
+
+/* Prototypes for local functions. */
+
+static void return_command (char *, int);
+
+static void down_command (char *, int);
+
+static void down_silently_base (char *);
+
+static void down_silently_command (char *, int);
+
+static void up_command (char *, int);
+
+static void up_silently_base (char *);
+
+static void up_silently_command (char *, int);
+
+void frame_command (char *, int);
+
+static void current_frame_command (char *, int);
+
+static void select_frame_command (char *, int);
+
+static void print_frame_arg_vars (struct frame_info *, struct ui_file *);
+
+static void catch_info (char *, int);
+
+static void args_plus_locals_info (char *, int);
+
+static void print_frame_label_vars (struct frame_info *, int,
+				    struct ui_file *);
+
+static void print_frame_local_vars (struct frame_info *, int,
+				    struct ui_file *);
+
+static int print_block_frame_labels (struct block *, int *,
+				     struct ui_file *);
+
+static int print_block_frame_locals (struct block *,
+				     struct frame_info *,
+				     int,
+				     struct ui_file *);
+
+static void print_frame (struct frame_info *fi, 
+			 int level, 
+			 int source, 
+			 int args, 
+			 struct symtab_and_line sal);
+
+static void print_frame_info_base (struct frame_info *, int, int, int);
+
+static void print_stack_frame_base (struct frame_info *, int, int);
+
+static void backtrace_command (char *, int);
+
+struct frame_info *parse_frame_specification (char *);
+
+static void frame_info (char *, int);
+
+extern int addressprint;	/* Print addresses, or stay symbolic only? */
+
+/* The "selected" stack frame is used by default for local and arg access.
+   May be zero, for no selected frame.  */
+
+struct frame_info *selected_frame;
+
+/* Level of the selected frame:
+   0 for innermost, 1 for its caller, ...
+   or -1 for frame specified by address with no defined level.  */
+
+/* Level of the selected frame: 0 for innermost, 1 for its caller, ...
+   or -1 for NULL frame.  */
+
+int
+frame_relative_level (struct frame_info *fi)
+{
+  if (fi == NULL)
+    return -1;
+  else
+    return fi->level;
+}
+
+/* Zero means do things normally; we are interacting directly with the
+   user.  One means print the full filename and linenumber when a
+   frame is printed, and do so in a format emacs18/emacs19.22 can
+   parse.  Two means print similar annotations, but in many more
+   cases and in a slightly different syntax.  */
+
+int annotation_level = 0;
+
+
+struct print_stack_frame_args
+  {
+    struct frame_info *fi;
+    int level;
+    int source;
+    int args;
+  };
+
+static int print_stack_frame_base_stub (char *);
+
+/* Show and print the frame arguments.
+   Pass the args the way catch_errors wants them.  */
+static int show_and_print_stack_frame_stub (void *args);
+static int
+show_and_print_stack_frame_stub (void *args)
+{
+  struct print_stack_frame_args *p = (struct print_stack_frame_args *) args;
+
+  print_frame_info (p->fi, p->level, p->source, p->args);
+
+  return 0;
+}
+
+/* Show or print the frame arguments.
+   Pass the args the way catch_errors wants them.  */
+static int print_stack_frame_stub (void *args);
+static int
+print_stack_frame_stub (void *args)
+{
+  struct print_stack_frame_args *p = (struct print_stack_frame_args *) args;
+
+  print_frame_info_base (p->fi, p->level, p->source, p->args);
+  return 0;
+}
+
+/* Print a stack frame briefly.  FRAME_INFI should be the frame info
+   and LEVEL should be its level in the stack (or -1 for level not
+   defined). */
+
+/* Pass the args the way catch_errors wants them.  */
+static int
+print_stack_frame_base_stub (char *args)
+{
+  struct print_stack_frame_args *p = (struct print_stack_frame_args *) args;
+
+  print_frame_info_base (p->fi, p->level, p->source, p->args);
+  return 0;
+}
+
+/* print the frame arguments to the terminal.  
+   Pass the args the way catch_errors wants them.  */
+static int print_only_stack_frame_stub (void *);
+static int
+print_only_stack_frame_stub (void *args)
+{
+  struct print_stack_frame_args *p = (struct print_stack_frame_args *) args;
+
+  print_frame_info_base (p->fi, p->level, p->source, p->args);
+  return 0;
+}
+
+/* Print a stack frame briefly.  FRAME_INFI should be the frame info
+   and LEVEL should be its level in the stack (or -1 for level not defined).
+   This prints the level, the function executing, the arguments,
+   and the file name and line number.
+   If the pc is not at the beginning of the source line,
+   the actual pc is printed at the beginning.
+
+   If SOURCE is 1, print the source line as well.
+   If SOURCE is -1, print ONLY the source line.  */
+
+static void
+print_stack_frame_base (struct frame_info *fi, int level, int source)
+{
+  struct print_stack_frame_args args;
+
+  args.fi = fi;
+  args.level = level;
+  args.source = source;
+  args.args = 1;
+
+  catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ALL);
+}
+
+/* Show and print a stack frame briefly.  FRAME_INFI should be the frame info
+   and LEVEL should be its level in the stack (or -1 for level not defined).
+   This prints the level, the function executing, the arguments,
+   and the file name and line number.
+   If the pc is not at the beginning of the source line,
+   the actual pc is printed at the beginning.
+
+   If SOURCE is 1, print the source line as well.
+   If SOURCE is -1, print ONLY the source line.  */
+
+void
+show_and_print_stack_frame (struct frame_info *fi, int level, int source)
+{
+  struct print_stack_frame_args args;
+
+  args.fi = fi;
+  args.level = level;
+  args.source = source;
+  args.args = 1;
+
+  catch_errors (show_and_print_stack_frame_stub, &args, "", RETURN_MASK_ALL);
+}
+
+
+/* Show or print a stack frame briefly.  FRAME_INFI should be the frame info
+   and LEVEL should be its level in the stack (or -1 for level not defined).
+   This prints the level, the function executing, the arguments,
+   and the file name and line number.
+   If the pc is not at the beginning of the source line,
+   the actual pc is printed at the beginning.
+
+   If SOURCE is 1, print the source line as well.
+   If SOURCE is -1, print ONLY the source line.  */
+
+void
+print_stack_frame (struct frame_info *fi, int level, int source)
+{
+  struct print_stack_frame_args args;
+
+  args.fi = fi;
+  args.level = level;
+  args.source = source;
+  args.args = 1;
+
+  catch_errors (print_stack_frame_stub, (char *) &args, "", RETURN_MASK_ALL);
+}
+
+/* Print a stack frame briefly.  FRAME_INFI should be the frame info
+   and LEVEL should be its level in the stack (or -1 for level not defined).
+   This prints the level, the function executing, the arguments,
+   and the file name and line number.
+   If the pc is not at the beginning of the source line,
+   the actual pc is printed at the beginning.
+
+   If SOURCE is 1, print the source line as well.
+   If SOURCE is -1, print ONLY the source line.  */
+
+void
+print_only_stack_frame (struct frame_info *fi, int level, int source)
+{
+  struct print_stack_frame_args args;
+
+  args.fi = fi;
+  args.level = level;
+  args.source = source;
+  args.args = 1;
+
+  catch_errors (print_only_stack_frame_stub, &args, "", RETURN_MASK_ALL);
+}
+
+struct print_args_args
+{
+  struct symbol *func;
+  struct frame_info *fi;
+  struct ui_file *stream;
+};
+
+static int print_args_stub (PTR);
+
+/* Pass the args the way catch_errors wants them.  */
+
+static int
+print_args_stub (PTR args)
+{
+  int numargs;
+  struct print_args_args *p = (struct print_args_args *) args;
+
+  numargs = FRAME_NUM_ARGS (p->fi);
+  print_frame_args (p->func, p->fi, numargs, p->stream);
+  return 0;
+}
+
+/* Print information about a frame for frame "fi" at level "level".
+   Used in "where" output, also used to emit breakpoint or step
+   messages.  
+   LEVEL is the level of the frame, or -1 if it is the
+   innermost frame but we don't want to print the level.  
+   The meaning of the SOURCE argument is: 
+   SRC_LINE: Print only source line
+   LOCATION: Print only location 
+   LOC_AND_SRC: Print location and source line.  */
+
+static void
+print_frame_info_base (struct frame_info *fi, int level, int source, int args)
+{
+  struct symtab_and_line sal;
+  int source_print;
+  int location_print;
+
+#if 0
+  char buf[MAX_REGISTER_RAW_SIZE];
+  CORE_ADDR sp;
+
+  /* On the 68k, this spends too much time in m68k_find_saved_regs.  */
+
+  /* Get the value of SP_REGNUM relative to the frame.  */
+  get_saved_register (buf, (int *) NULL, (CORE_ADDR *) NULL,
+		    FRAME_INFO_ID (fi), SP_REGNUM, (enum lval_type *) NULL);
+  sp = extract_address (buf, REGISTER_RAW_SIZE (SP_REGNUM));
+
+  /* This is not a perfect test, because if a function alloca's some
+     memory, puts some code there, and then jumps into it, then the test
+     will succeed even though there is no call dummy.  Probably best is
+     to check for a bp_call_dummy breakpoint.  */
+  if (PC_IN_CALL_DUMMY (fi->pc, sp, fi->frame))
+#else
+  if (frame_in_dummy (fi))
+#endif
+    {
+      annotate_frame_begin (level == -1 ? 0 : level, fi->pc);
+
+      /* Do this regardless of SOURCE because we don't have any source
+         to list for this frame.  */
+      if (level >= 0)
+	printf_filtered ("#%-2d ", level);
+      annotate_function_call ();
+      printf_filtered ("<function called from gdb>\n");
+      annotate_frame_end ();
+      return;
+    }
+  if (fi->signal_handler_caller)
+    {
+      annotate_frame_begin (level == -1 ? 0 : level, fi->pc);
+
+      /* Do this regardless of SOURCE because we don't have any source
+         to list for this frame.  */
+      if (level >= 0)
+	printf_filtered ("#%-2d ", level);
+      annotate_signal_handler_caller ();
+      printf_filtered ("<signal handler called>\n");
+      annotate_frame_end ();
+      return;
+    }
+
+  /* If fi is not the innermost frame, that normally means that fi->pc
+     points to *after* the call instruction, and we want to get the line
+     containing the call, never the next line.  But if the next frame is
+     a signal_handler_caller or a dummy frame, then the next frame was
+     not entered as the result of a call, and we want to get the line
+     containing fi->pc.  */
+  sal =
+    find_pc_line (fi->pc,
+		  fi->next != NULL
+		  && !fi->next->signal_handler_caller
+		  && !frame_in_dummy (fi->next));
+
+  location_print = (source == LOCATION 
+		    || source == LOC_AND_ADDRESS
+		    || source == SRC_AND_LOC);
+
+  if (location_print || !sal.symtab)
+    print_frame (fi, level, source, args, sal);
+
+  source_print = (source == SRC_LINE || source == SRC_AND_LOC);
+
+  if (sal.symtab)
+    set_current_source_symtab_and_line (&sal);
+
+  if (source_print && sal.symtab)
+    {
+      struct symtab_and_line cursal;
+      int done = 0;
+      int mid_statement = (source == SRC_LINE) && (fi->pc != sal.pc);
+
+      if (annotation_level)
+	done = identify_source_line (sal.symtab, sal.line, mid_statement,
+				     fi->pc);
+      if (!done)
+	{
+	  if (print_frame_info_listing_hook)
+	    print_frame_info_listing_hook (sal.symtab, sal.line, sal.line + 1, 0);
+	  else
+	    {
+	      /* We used to do this earlier, but that is clearly
+		 wrong. This function is used by many different
+		 parts of gdb, including normal_stop in infrun.c,
+		 which uses this to print out the current PC
+		 when we stepi/nexti into the middle of a source
+		 line. Only the command line really wants this
+		 behavior. Other UIs probably would like the
+		 ability to decide for themselves if it is desired. */
+	      if (addressprint && mid_statement)
+		{
+		  ui_out_field_core_addr (uiout, "addr", fi->pc);
+		  ui_out_text (uiout, "\t");
+		}
+
+	      print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
+	    }
+	}
+      cursal = get_current_or_default_source_symtab_and_line ();
+      cursal.line = max (sal.line - get_lines_to_list () / 2, 1);
+      set_current_source_symtab_and_line (&cursal);
+    }
+
+  if (source != 0)
+    set_default_breakpoint (1, fi->pc, sal.symtab, sal.line);
+
+  annotate_frame_end ();
+
+  gdb_flush (gdb_stdout);
+}
+
+static void
+print_frame (struct frame_info *fi, 
+	     int level, 
+	     int source, 
+	     int args, 
+	     struct symtab_and_line sal)
+{
+  struct symbol *func;
+  register char *funname = 0;
+  enum language funlang = language_unknown;
+  struct ui_stream *stb;
+  struct cleanup *old_chain;
+  struct cleanup *list_chain;
+
+  stb = ui_out_stream_new (uiout);
+  old_chain = make_cleanup_ui_out_stream_delete (stb);
+
+  func = find_pc_function (frame_address_in_block (fi));
+  if (func)
+    {
+      /* In certain pathological cases, the symtabs give the wrong
+         function (when we are in the first function in a file which
+         is compiled without debugging symbols, the previous function
+         is compiled with debugging symbols, and the "foo.o" symbol
+         that is supposed to tell us where the file with debugging symbols
+         ends has been truncated by ar because it is longer than 15
+         characters).  This also occurs if the user uses asm() to create
+         a function but not stabs for it (in a file compiled -g).
+
+         So look in the minimal symbol tables as well, and if it comes
+         up with a larger address for the function use that instead.
+         I don't think this can ever cause any problems; there shouldn't
+         be any minimal symbols in the middle of a function; if this is
+         ever changed many parts of GDB will need to be changed (and we'll
+         create a find_pc_minimal_function or some such).  */
+
+      struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (frame_address_in_block (fi));
+      if (msymbol != NULL
+	  && (SYMBOL_VALUE_ADDRESS (msymbol)
+	      > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
+	{
+#if 0
+	  /* There is no particular reason to think the line number
+	     information is wrong.  Someone might have just put in
+	     a label with asm() but left the line numbers alone.  */
+	  /* In this case we have no way of knowing the source file
+	     and line number, so don't print them.  */
+	  sal.symtab = 0;
+#endif
+	  /* We also don't know anything about the function besides
+	     its address and name.  */
+	  func = 0;
+	  funname = SYMBOL_NAME (msymbol);
+	  funlang = SYMBOL_LANGUAGE (msymbol);
+	}
+      else
+	{
+	  /* I'd like to use SYMBOL_SOURCE_NAME() here, to display the
+	     demangled name that we already have stored in the symbol
+	     table, but we stored a version with DMGL_PARAMS turned
+	     on, and here we don't want to display parameters. So call
+	     the demangler again, with DMGL_ANSI only. (Yes, I know
+	     that printf_symbol_filtered() will again try to demangle
+	     the name on the fly, but the issue is that if
+	     cplus_demangle() fails here, it'll fail there too. So we
+	     want to catch the failure ("demangled==NULL" case below)
+	     here, while we still have our hands on the function
+	     symbol.) */
+	  char *demangled;
+	  funname = SYMBOL_NAME (func);
+	  funlang = SYMBOL_LANGUAGE (func);
+	  if (funlang == language_cplus)
+	    {
+	      demangled = cplus_demangle (funname, DMGL_ANSI);
+	      if (demangled == NULL)
+		/* If the demangler fails, try the demangled name from
+		   the symbol table. This'll have parameters, but
+		   that's preferable to diplaying a mangled name. */
+		funname = SYMBOL_SOURCE_NAME (func);
+	    }
+	}
+    }
+  else
+    {
+      struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (frame_address_in_block (fi));
+      if (msymbol != NULL)
+	{
+	  funname = SYMBOL_NAME (msymbol);
+	  funlang = SYMBOL_LANGUAGE (msymbol);
+	}
+    }
+
+  annotate_frame_begin (level == -1 ? 0 : level, fi->pc);
+
+  list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
+
+  if (level >= 0)
+    {
+      ui_out_text (uiout, "#");
+      ui_out_field_fmt (uiout, "level", "%-2d", level);
+      ui_out_spaces (uiout, 1);
+    }
+  if (addressprint)
+    if (fi->pc != sal.pc || !sal.symtab || source == LOC_AND_ADDRESS)
+      {
+	annotate_frame_address ();
+	ui_out_field_core_addr (uiout, "addr", fi->pc);
+	annotate_frame_address_end ();
+	ui_out_text (uiout, " in ");
+      }
+  annotate_frame_function_name ();
+  fprintf_symbol_filtered (stb->stream, funname ? funname : "??", funlang,
+			   DMGL_ANSI);
+  ui_out_field_stream (uiout, "func", stb);
+  ui_out_wrap_hint (uiout, "   ");
+  annotate_frame_args ();
+      
+  ui_out_text (uiout, " (");
+  if (args)
+    {
+      struct print_args_args args;
+      struct cleanup *args_list_chain;
+      args.fi = fi;
+      args.func = func;
+      args.stream = gdb_stdout;
+      args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
+      catch_errors (print_args_stub, &args, "", RETURN_MASK_ALL);
+      /* FIXME: args must be a list. If one argument is a string it will
+		 have " that will not be properly escaped.  */
+      /* Invoke ui_out_tuple_end.  */
+      do_cleanups (args_list_chain);
+      QUIT;
+    }
+  ui_out_text (uiout, ")");
+  if (sal.symtab && sal.symtab->filename)
+    {
+      annotate_frame_source_begin ();
+      ui_out_wrap_hint (uiout, "   ");
+      ui_out_text (uiout, " at ");
+      annotate_frame_source_file ();
+      ui_out_field_string (uiout, "file", sal.symtab->filename);
+      annotate_frame_source_file_end ();
+      ui_out_text (uiout, ":");
+      annotate_frame_source_line ();
+      ui_out_field_int (uiout, "line", sal.line);
+      annotate_frame_source_end ();
+    }
+
+#ifdef PC_SOLIB
+  if (!funname || (!sal.symtab || !sal.symtab->filename))
+    {
+      char *lib = PC_SOLIB (fi->pc);
+      if (lib)
+	{
+	  annotate_frame_where ();
+	  ui_out_wrap_hint (uiout, "  ");
+	  ui_out_text (uiout, " from ");
+	  ui_out_field_string (uiout, "from", lib);
+	}
+    }
+#endif /* PC_SOLIB */
+
+  /* do_cleanups will call ui_out_tuple_end() for us.  */
+  do_cleanups (list_chain);
+  ui_out_text (uiout, "\n");
+  do_cleanups (old_chain);
+}
+
+
+/* Show or print the frame info.  If this is the tui, it will be shown in 
+   the source display */
+void
+print_frame_info (struct frame_info *fi, register int level, int source,
+		  int args)
+{
+  print_frame_info_base (fi, level, source, args);
+}
+
+/* Show the frame info.  If this is the tui, it will be shown in 
+   the source display otherwise, nothing is done */
+void
+show_stack_frame (struct frame_info *fi)
+{
+}
+
+
+/* Read a frame specification in whatever the appropriate format is.
+   Call error() if the specification is in any way invalid (i.e.
+   this function never returns NULL).  */
+
+struct frame_info *
+parse_frame_specification (char *frame_exp)
+{
+  int numargs = 0;
+#define	MAXARGS	4
+  CORE_ADDR args[MAXARGS];
+  int level;
+
+  if (frame_exp)
+    {
+      char *addr_string, *p;
+      struct cleanup *tmp_cleanup;
+
+      while (*frame_exp == ' ')
+	frame_exp++;
+
+      while (*frame_exp)
+	{
+	  if (numargs > MAXARGS)
+	    error ("Too many args in frame specification");
+	  /* Parse an argument.  */
+	  for (p = frame_exp; *p && *p != ' '; p++)
+	    ;
+	  addr_string = savestring (frame_exp, p - frame_exp);
+
+	  {
+	    struct value *vp;
+
+	    tmp_cleanup = make_cleanup (xfree, addr_string);
+
+	    /* NOTE: we call parse_and_eval and then both
+	       value_as_long and value_as_address rather than calling
+	       parse_and_eval_long and parse_and_eval_address because
+	       of the issue of potential side effects from evaluating
+	       the expression.  */
+	    vp = parse_and_eval (addr_string);
+	    if (numargs == 0)
+	      level = value_as_long (vp);
+
+	    args[numargs++] = value_as_address (vp);
+	    do_cleanups (tmp_cleanup);
+	  }
+
+	  /* Skip spaces, move to possible next arg.  */
+	  while (*p == ' ')
+	    p++;
+	  frame_exp = p;
+	}
+    }
+
+  switch (numargs)
+    {
+    case 0:
+      if (selected_frame == NULL)
+	error ("No selected frame.");
+      return selected_frame;
+      /* NOTREACHED */
+    case 1:
+      {
+	struct frame_info *fid =
+	find_relative_frame (get_current_frame (), &level);
+	struct frame_info *tfid;
+
+	if (level == 0)
+	  /* find_relative_frame was successful */
+	  return fid;
+
+	/* If SETUP_ARBITRARY_FRAME is defined, then frame specifications
+	   take at least 2 addresses.  It is important to detect this case
+	   here so that "frame 100" does not give a confusing error message
+	   like "frame specification requires two addresses".  This of course
+	   does not solve the "frame 100" problem for machines on which
+	   a frame specification can be made with one address.  To solve
+	   that, we need a new syntax for a specifying a frame by address.
+	   I think the cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for
+	   two args, etc.), but people might think that is too much typing,
+	   so I guess *0x23,0x45 would be a possible alternative (commas
+	   really should be used instead of spaces to delimit; using spaces
+	   normally works in an expression).  */
+#ifdef SETUP_ARBITRARY_FRAME
+	error ("No frame %s", paddr_d (args[0]));
+#endif
+
+	/* If (s)he specifies the frame with an address, he deserves what
+	   (s)he gets.  Still, give the highest one that matches.  */
+
+	for (fid = get_current_frame ();
+	     fid && fid->frame != args[0];
+	     fid = get_prev_frame (fid))
+	  ;
+
+	if (fid)
+	  while ((tfid = get_prev_frame (fid)) &&
+		 (tfid->frame == args[0]))
+	    fid = tfid;
+
+	/* We couldn't identify the frame as an existing frame, but
+	   perhaps we can create one with a single argument.  */
+      }
+
+    default:
+#ifdef SETUP_ARBITRARY_FRAME
+      return SETUP_ARBITRARY_FRAME (numargs, args);
+#else
+      /* Usual case.  Do it here rather than have everyone supply
+         a SETUP_ARBITRARY_FRAME that does this.  */
+      if (numargs == 1)
+	return create_new_frame (args[0], 0);
+      error ("Too many args in frame specification");
+#endif
+      /* NOTREACHED */
+    }
+  /* NOTREACHED */
+}
+
+/* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except
+   that if it is unsure about the answer, it returns 0
+   instead of guessing (this happens on the VAX and i960, for example).
+
+   On most machines, we never have to guess about the args address,
+   so FRAME_ARGS_ADDRESS{,_CORRECT} are the same.  */
+#if !defined (FRAME_ARGS_ADDRESS_CORRECT)
+#define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS
+#endif
+
+/* Print verbosely the selected frame or the frame at address ADDR.
+   This means absolutely all information in the frame is printed.  */
+
+static void
+frame_info (char *addr_exp, int from_tty)
+{
+  struct frame_info *fi;
+  struct symtab_and_line sal;
+  struct symbol *func;
+  struct symtab *s;
+  struct frame_info *calling_frame_info;
+  int i, count, numregs;
+  char *funname = 0;
+  enum language funlang = language_unknown;
+
+  if (!target_has_stack)
+    error ("No stack.");
+
+  fi = parse_frame_specification (addr_exp);
+  if (fi == NULL)
+    error ("Invalid frame specified.");
+
+  sal = find_pc_line (fi->pc,
+		      fi->next != NULL
+		      && !fi->next->signal_handler_caller
+		      && !frame_in_dummy (fi->next));
+  func = get_frame_function (fi);
+  s = find_pc_symtab (fi->pc);
+  if (func)
+    {
+      /* I'd like to use SYMBOL_SOURCE_NAME() here, to display
+       * the demangled name that we already have stored in
+       * the symbol table, but we stored a version with
+       * DMGL_PARAMS turned on, and here we don't want
+       * to display parameters. So call the demangler again,
+       * with DMGL_ANSI only. RT
+       * (Yes, I know that printf_symbol_filtered() will
+       * again try to demangle the name on the fly, but
+       * the issue is that if cplus_demangle() fails here,
+       * it'll fail there too. So we want to catch the failure
+       * ("demangled==NULL" case below) here, while we still
+       * have our hands on the function symbol.)
+       */
+      char *demangled;
+      funname = SYMBOL_NAME (func);
+      funlang = SYMBOL_LANGUAGE (func);
+      if (funlang == language_cplus)
+	{
+	  demangled = cplus_demangle (funname, DMGL_ANSI);
+	  /* If the demangler fails, try the demangled name
+	   * from the symbol table. This'll have parameters,
+	   * but that's preferable to diplaying a mangled name.
+	   */
+	  if (demangled == NULL)
+	    funname = SYMBOL_SOURCE_NAME (func);
+	}
+    }
+  else
+    {
+      register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
+      if (msymbol != NULL)
+	{
+	  funname = SYMBOL_NAME (msymbol);
+	  funlang = SYMBOL_LANGUAGE (msymbol);
+	}
+    }
+  calling_frame_info = get_prev_frame (fi);
+
+  if (!addr_exp && frame_relative_level (selected_frame) >= 0)
+    {
+      printf_filtered ("Stack level %d, frame at ",
+		       frame_relative_level (selected_frame));
+      print_address_numeric (fi->frame, 1, gdb_stdout);
+      printf_filtered (":\n");
+    }
+  else
+    {
+      printf_filtered ("Stack frame at ");
+      print_address_numeric (fi->frame, 1, gdb_stdout);
+      printf_filtered (":\n");
+    }
+  printf_filtered (" %s = ", REGISTER_NAME (PC_REGNUM));
+  print_address_numeric (fi->pc, 1, gdb_stdout);
+
+  wrap_here ("   ");
+  if (funname)
+    {
+      printf_filtered (" in ");
+      fprintf_symbol_filtered (gdb_stdout, funname, funlang,
+			       DMGL_ANSI | DMGL_PARAMS);
+    }
+  wrap_here ("   ");
+  if (sal.symtab)
+    printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
+  puts_filtered ("; ");
+  wrap_here ("    ");
+  printf_filtered ("saved %s ", REGISTER_NAME (PC_REGNUM));
+  print_address_numeric (FRAME_SAVED_PC (fi), 1, gdb_stdout);
+  printf_filtered ("\n");
+
+  {
+    int frameless;
+    frameless = FRAMELESS_FUNCTION_INVOCATION (fi);
+    if (frameless)
+      printf_filtered (" (FRAMELESS),");
+  }
+
+  if (calling_frame_info)
+    {
+      printf_filtered (" called by frame at ");
+      print_address_numeric (calling_frame_info->frame, 1, gdb_stdout);
+    }
+  if (fi->next && calling_frame_info)
+    puts_filtered (",");
+  wrap_here ("   ");
+  if (fi->next)
+    {
+      printf_filtered (" caller of frame at ");
+      print_address_numeric (fi->next->frame, 1, gdb_stdout);
+    }
+  if (fi->next || calling_frame_info)
+    puts_filtered ("\n");
+  if (s)
+    printf_filtered (" source language %s.\n", language_str (s->language));
+
+#ifdef PRINT_EXTRA_FRAME_INFO
+  PRINT_EXTRA_FRAME_INFO (fi);
+#endif
+
+  {
+    /* Address of the argument list for this frame, or 0.  */
+    CORE_ADDR arg_list = FRAME_ARGS_ADDRESS_CORRECT (fi);
+    /* Number of args for this frame, or -1 if unknown.  */
+    int numargs;
+
+    if (arg_list == 0)
+      printf_filtered (" Arglist at unknown address.\n");
+    else
+      {
+	printf_filtered (" Arglist at ");
+	print_address_numeric (arg_list, 1, gdb_stdout);
+	printf_filtered (",");
+
+	numargs = FRAME_NUM_ARGS (fi);
+	if (numargs < 0)
+	  puts_filtered (" args: ");
+	else if (numargs == 0)
+	  puts_filtered (" no args.");
+	else if (numargs == 1)
+	  puts_filtered (" 1 arg: ");
+	else
+	  printf_filtered (" %d args: ", numargs);
+	print_frame_args (func, fi, numargs, gdb_stdout);
+	puts_filtered ("\n");
+      }
+  }
+  {
+    /* Address of the local variables for this frame, or 0.  */
+    CORE_ADDR arg_list = FRAME_LOCALS_ADDRESS (fi);
+
+    if (arg_list == 0)
+      printf_filtered (" Locals at unknown address,");
+    else
+      {
+	printf_filtered (" Locals at ");
+	print_address_numeric (arg_list, 1, gdb_stdout);
+	printf_filtered (",");
+      }
+  }
+
+  if (fi->saved_regs == NULL)
+    FRAME_INIT_SAVED_REGS (fi);
+  /* Print as much information as possible on the location of all the
+     registers.  */
+  {
+    enum lval_type lval;
+    int optimized;
+    CORE_ADDR addr;
+    int realnum;
+    int count;
+    int i;
+    int need_nl = 1;
+
+    /* The sp is special; what's displayed isn't the save address, but
+       the value of the previous frame's sp.  This is a legacy thing,
+       at one stage the frame cached the previous frame's SP instead
+       of its address, hence it was easiest to just display the cached
+       value.  */
+    if (SP_REGNUM >= 0)
+      {
+	/* Find out the location of the saved stack pointer with out
+           actually evaluating it.  */
+	frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr,
+			       &realnum, NULL);
+	if (!optimized && lval == not_lval)
+	  {
+	    void *value = alloca (MAX_REGISTER_RAW_SIZE);
+	    CORE_ADDR sp;
+	    frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr,
+				   &realnum, value);
+	    sp = extract_address (value, REGISTER_RAW_SIZE (SP_REGNUM));
+	    printf_filtered (" Previous frame's sp is ");
+	    print_address_numeric (sp, 1, gdb_stdout);
+	    printf_filtered ("\n");
+	    need_nl = 0;
+	  }
+	else if (!optimized && lval == lval_memory)
+	  {
+	    printf_filtered (" Previous frame's sp at ");
+	    print_address_numeric (addr, 1, gdb_stdout);
+	    printf_filtered ("\n");
+	    need_nl = 0;
+	  }
+	else if (!optimized && lval == lval_register)
+	  {
+	    printf_filtered (" Previous frame's sp in %s\n",
+			     REGISTER_NAME (realnum));
+	    need_nl = 0;
+	  }
+	/* else keep quiet.  */
+      }
+
+    count = 0;
+    numregs = NUM_REGS + NUM_PSEUDO_REGS;
+    for (i = 0; i < numregs; i++)
+      if (i != SP_REGNUM)
+	{
+	  /* Find out the location of the saved register without
+             fetching the corresponding value.  */
+	  frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
+				 NULL);
+	  /* For moment, only display registers that were saved on the
+	     stack.  */
+	  if (!optimized && lval == lval_memory)
+	    {
+	      if (count == 0)
+		puts_filtered (" Saved registers:\n ");
+	      else
+		puts_filtered (",");
+	      wrap_here (" ");
+	      printf_filtered (" %s at ", REGISTER_NAME (i));
+	      print_address_numeric (addr, 1, gdb_stdout);
+	      count++;
+	    }
+	}
+    if (count || need_nl)
+      puts_filtered ("\n");
+  }
+}
+
+#if 0
+/* Set a limit on the number of frames printed by default in a
+   backtrace.  */
+
+static int backtrace_limit;
+
+static void
+set_backtrace_limit_command (char *count_exp, int from_tty)
+{
+  int count = parse_and_eval_long (count_exp);
+
+  if (count < 0)
+    error ("Negative argument not meaningful as backtrace limit.");
+
+  backtrace_limit = count;
+}
+
+static void
+backtrace_limit_info (char *arg, int from_tty)
+{
+  if (arg)
+    error ("\"Info backtrace-limit\" takes no arguments.");
+
+  printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit);
+}
+#endif
+
+/* Print briefly all stack frames or just the innermost COUNT frames.  */
+
+static void backtrace_command_1 (char *count_exp, int show_locals,
+				 int from_tty);
+static void
+backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
+{
+  struct frame_info *fi;
+  register int count;
+  register int i;
+  register struct frame_info *trailing;
+  register int trailing_level;
+
+  if (!target_has_stack)
+    error ("No stack.");
+
+  /* The following code must do two things.  First, it must
+     set the variable TRAILING to the frame from which we should start
+     printing.  Second, it must set the variable count to the number
+     of frames which we should print, or -1 if all of them.  */
+  trailing = get_current_frame ();
+
+  /* The target can be in a state where there is no valid frames
+     (e.g., just connected). */
+  if (trailing == NULL)
+    error ("No stack.");
+
+  trailing_level = 0;
+  if (count_exp)
+    {
+      count = parse_and_eval_long (count_exp);
+      if (count < 0)
+	{
+	  struct frame_info *current;
+
+	  count = -count;
+
+	  current = trailing;
+	  while (current && count--)
+	    {
+	      QUIT;
+	      current = get_prev_frame (current);
+	    }
+
+	  /* Will stop when CURRENT reaches the top of the stack.  TRAILING
+	     will be COUNT below it.  */
+	  while (current)
+	    {
+	      QUIT;
+	      trailing = get_prev_frame (trailing);
+	      current = get_prev_frame (current);
+	      trailing_level++;
+	    }
+
+	  count = -1;
+	}
+    }
+  else
+    count = -1;
+
+  if (info_verbose)
+    {
+      struct partial_symtab *ps;
+
+      /* Read in symbols for all of the frames.  Need to do this in
+         a separate pass so that "Reading in symbols for xxx" messages
+         don't screw up the appearance of the backtrace.  Also
+         if people have strong opinions against reading symbols for
+         backtrace this may have to be an option.  */
+      i = count;
+      for (fi = trailing;
+	   fi != NULL && i--;
+	   fi = get_prev_frame (fi))
+	{
+	  QUIT;
+	  ps = find_pc_psymtab (frame_address_in_block (fi));
+	  if (ps)
+	    PSYMTAB_TO_SYMTAB (ps);	/* Force syms to come in */
+	}
+    }
+
+  for (i = 0, fi = trailing;
+       fi && count--;
+       i++, fi = get_prev_frame (fi))
+    {
+      QUIT;
+
+      /* Don't use print_stack_frame; if an error() occurs it probably
+         means further attempts to backtrace would fail (on the other
+         hand, perhaps the code does or could be fixed to make sure
+         the frame->prev field gets set to NULL in that case).  */
+      print_frame_info_base (fi, trailing_level + i, 0, 1);
+      if (show_locals)
+	print_frame_local_vars (fi, 1, gdb_stdout);
+    }
+
+  /* If we've stopped before the end, mention that.  */
+  if (fi && from_tty)
+    printf_filtered ("(More stack frames follow...)\n");
+}
+
+static void
+backtrace_command (char *arg, int from_tty)
+{
+  struct cleanup *old_chain = (struct cleanup *) NULL;
+  char **argv = (char **) NULL;
+  int argIndicatingFullTrace = (-1), totArgLen = 0, argc = 0;
+  char *argPtr = arg;
+
+  if (arg != (char *) NULL)
+    {
+      int i;
+
+      argv = buildargv (arg);
+      old_chain = make_cleanup_freeargv (argv);
+      argc = 0;
+      for (i = 0; (argv[i] != (char *) NULL); i++)
+	{
+	  unsigned int j;
+
+	  for (j = 0; (j < strlen (argv[i])); j++)
+	    argv[i][j] = tolower (argv[i][j]);
+
+	  if (argIndicatingFullTrace < 0 && subset_compare (argv[i], "full"))
+	    argIndicatingFullTrace = argc;
+	  else
+	    {
+	      argc++;
+	      totArgLen += strlen (argv[i]);
+	    }
+	}
+      totArgLen += argc;
+      if (argIndicatingFullTrace >= 0)
+	{
+	  if (totArgLen > 0)
+	    {
+	      argPtr = (char *) xmalloc (totArgLen + 1);
+	      if (!argPtr)
+		nomem (0);
+	      else
+		{
+		  memset (argPtr, 0, totArgLen + 1);
+		  for (i = 0; (i < (argc + 1)); i++)
+		    {
+		      if (i != argIndicatingFullTrace)
+			{
+			  strcat (argPtr, argv[i]);
+			  strcat (argPtr, " ");
+			}
+		    }
+		}
+	    }
+	  else
+	    argPtr = (char *) NULL;
+	}
+    }
+
+  backtrace_command_1 (argPtr, (argIndicatingFullTrace >= 0), from_tty);
+
+  if (argIndicatingFullTrace >= 0 && totArgLen > 0)
+    xfree (argPtr);
+
+  if (old_chain)
+    do_cleanups (old_chain);
+}
+
+static void backtrace_full_command (char *arg, int from_tty);
+static void
+backtrace_full_command (char *arg, int from_tty)
+{
+  backtrace_command_1 (arg, 1, from_tty);
+}
+
+
+/* Print the local variables of a block B active in FRAME.
+   Return 1 if any variables were printed; 0 otherwise.  */
+
+static int
+print_block_frame_locals (struct block *b, register struct frame_info *fi,
+			  int num_tabs, register struct ui_file *stream)
+{
+  register int i, j;
+  register struct symbol *sym;
+  register int values_printed = 0;
+
+  ALL_BLOCK_SYMBOLS (b, i, sym)
+    {
+      switch (SYMBOL_CLASS (sym))
+	{
+	case LOC_LOCAL:
+	case LOC_REGISTER:
+	case LOC_STATIC:
+	case LOC_BASEREG:
+	  values_printed = 1;
+	  for (j = 0; j < num_tabs; j++)
+	    fputs_filtered ("\t", stream);
+	  fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
+	  fputs_filtered (" = ", stream);
+	  print_variable_value (sym, fi, stream);
+	  fprintf_filtered (stream, "\n");
+	  break;
+
+	default:
+	  /* Ignore symbols which are not locals.  */
+	  break;
+	}
+    }
+  return values_printed;
+}
+
+/* Same, but print labels.  */
+
+static int
+print_block_frame_labels (struct block *b, int *have_default,
+			  register struct ui_file *stream)
+{
+  register int i;
+  register struct symbol *sym;
+  register int values_printed = 0;
+
+  ALL_BLOCK_SYMBOLS (b, i, sym)
+    {
+      if (STREQ (SYMBOL_NAME (sym), "default"))
+	{
+	  if (*have_default)
+	    continue;
+	  *have_default = 1;
+	}
+      if (SYMBOL_CLASS (sym) == LOC_LABEL)
+	{
+	  struct symtab_and_line sal;
+	  sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
+	  values_printed = 1;
+	  fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
+	  if (addressprint)
+	    {
+	      fprintf_filtered (stream, " ");
+	      print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, stream);
+	    }
+	  fprintf_filtered (stream, " in file %s, line %d\n",
+			    sal.symtab->filename, sal.line);
+	}
+    }
+  return values_printed;
+}
+
+/* Print on STREAM all the local variables in frame FRAME,
+   including all the blocks active in that frame
+   at its current pc.
+
+   Returns 1 if the job was done,
+   or 0 if nothing was printed because we have no info
+   on the function running in FRAME.  */
+
+static void
+print_frame_local_vars (register struct frame_info *fi, register int num_tabs,
+			register struct ui_file *stream)
+{
+  register struct block *block = get_frame_block (fi, 0);
+  register int values_printed = 0;
+
+  if (block == 0)
+    {
+      fprintf_filtered (stream, "No symbol table info available.\n");
+      return;
+    }
+
+  while (block != 0)
+    {
+      if (print_block_frame_locals (block, fi, num_tabs, stream))
+	values_printed = 1;
+      /* After handling the function's top-level block, stop.
+         Don't continue to its superblock, the block of
+         per-file symbols.  */
+      if (BLOCK_FUNCTION (block))
+	break;
+      block = BLOCK_SUPERBLOCK (block);
+    }
+
+  if (!values_printed)
+    {
+      fprintf_filtered (stream, "No locals.\n");
+    }
+}
+
+/* Same, but print labels.  */
+
+static void
+print_frame_label_vars (register struct frame_info *fi, int this_level_only,
+			register struct ui_file *stream)
+{
+  register struct blockvector *bl;
+  register struct block *block = get_frame_block (fi, 0);
+  register int values_printed = 0;
+  int index, have_default = 0;
+  char *blocks_printed;
+  CORE_ADDR pc = fi->pc;
+
+  if (block == 0)
+    {
+      fprintf_filtered (stream, "No symbol table info available.\n");
+      return;
+    }
+
+  bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
+  blocks_printed = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
+  memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
+
+  while (block != 0)
+    {
+      CORE_ADDR end = BLOCK_END (block) - 4;
+      int last_index;
+
+      if (bl != blockvector_for_pc (end, &index))
+	error ("blockvector blotch");
+      if (BLOCKVECTOR_BLOCK (bl, index) != block)
+	error ("blockvector botch");
+      last_index = BLOCKVECTOR_NBLOCKS (bl);
+      index += 1;
+
+      /* Don't print out blocks that have gone by.  */
+      while (index < last_index
+	     && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
+	index++;
+
+      while (index < last_index
+	     && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
+	{
+	  if (blocks_printed[index] == 0)
+	    {
+	      if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index), &have_default, stream))
+		values_printed = 1;
+	      blocks_printed[index] = 1;
+	    }
+	  index++;
+	}
+      if (have_default)
+	return;
+      if (values_printed && this_level_only)
+	return;
+
+      /* After handling the function's top-level block, stop.
+         Don't continue to its superblock, the block of
+         per-file symbols.  */
+      if (BLOCK_FUNCTION (block))
+	break;
+      block = BLOCK_SUPERBLOCK (block);
+    }
+
+  if (!values_printed && !this_level_only)
+    {
+      fprintf_filtered (stream, "No catches.\n");
+    }
+}
+
+/* ARGSUSED */
+void
+locals_info (char *args, int from_tty)
+{
+  if (!selected_frame)
+    error ("No frame selected.");
+  print_frame_local_vars (selected_frame, 0, gdb_stdout);
+}
+
+static void
+catch_info (char *ignore, int from_tty)
+{
+  struct symtab_and_line *sal;
+
+  /* Check for target support for exception handling */
+  sal = target_enable_exception_callback (EX_EVENT_CATCH, 1);
+  if (sal)
+    {
+      /* Currently not handling this */
+      /* Ideally, here we should interact with the C++ runtime
+         system to find the list of active handlers, etc. */
+      fprintf_filtered (gdb_stdout, "Info catch not supported with this target/compiler combination.\n");
+#if 0
+      if (!selected_frame)
+	error ("No frame selected.");
+#endif
+    }
+  else
+    {
+      /* Assume g++ compiled code -- old v 4.16 behaviour */
+      if (!selected_frame)
+	error ("No frame selected.");
+
+      print_frame_label_vars (selected_frame, 0, gdb_stdout);
+    }
+}
+
+static void
+print_frame_arg_vars (register struct frame_info *fi,
+		      register struct ui_file *stream)
+{
+  struct symbol *func = get_frame_function (fi);
+  register struct block *b;
+  register int i;
+  register struct symbol *sym, *sym2;
+  register int values_printed = 0;
+
+  if (func == 0)
+    {
+      fprintf_filtered (stream, "No symbol table info available.\n");
+      return;
+    }
+
+  b = SYMBOL_BLOCK_VALUE (func);
+  ALL_BLOCK_SYMBOLS (b, i, sym)
+    {
+      switch (SYMBOL_CLASS (sym))
+	{
+	case LOC_ARG:
+	case LOC_LOCAL_ARG:
+	case LOC_REF_ARG:
+	case LOC_REGPARM:
+	case LOC_REGPARM_ADDR:
+	case LOC_BASEREG_ARG:
+	  values_printed = 1;
+	  fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
+	  fputs_filtered (" = ", stream);
+
+	  /* We have to look up the symbol because arguments can have
+	     two entries (one a parameter, one a local) and the one we
+	     want is the local, which lookup_symbol will find for us.
+	     This includes gcc1 (not gcc2) on the sparc when passing a
+	     small structure and gcc2 when the argument type is float
+	     and it is passed as a double and converted to float by
+	     the prologue (in the latter case the type of the LOC_ARG
+	     symbol is double and the type of the LOC_LOCAL symbol is
+	     float).  There are also LOC_ARG/LOC_REGISTER pairs which
+	     are not combined in symbol-reading.  */
+
+	  sym2 = lookup_symbol (SYMBOL_NAME (sym),
+		   b, VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
+	  print_variable_value (sym2, fi, stream);
+	  fprintf_filtered (stream, "\n");
+	  break;
+
+	default:
+	  /* Don't worry about things which aren't arguments.  */
+	  break;
+	}
+    }
+  if (!values_printed)
+    {
+      fprintf_filtered (stream, "No arguments.\n");
+    }
+}
+
+void
+args_info (char *ignore, int from_tty)
+{
+  if (!selected_frame)
+    error ("No frame selected.");
+  print_frame_arg_vars (selected_frame, gdb_stdout);
+}
+
+
+static void
+args_plus_locals_info (char *ignore, int from_tty)
+{
+  args_info (ignore, from_tty);
+  locals_info (ignore, from_tty);
+}
+
+
+/* Select frame FI (or NULL - to invalidate the current frame).  */
+
+void
+select_frame (struct frame_info *fi)
+{
+  register struct symtab *s;
+
+  selected_frame = fi;
+  /* NOTE: cagney/2002-05-04: FI can be NULL.  This occures when the
+     frame is being invalidated.  */
+  if (selected_frame_level_changed_hook)
+    selected_frame_level_changed_hook (frame_relative_level (fi));
+
+  /* FIXME: kseitz/2002-08-28: It would be nice to call
+     selected_frame_level_changed_event right here, but due to limitations
+     in the current interfaces, we would end up flooding UIs with events
+     because select_frame is used extensively internally.
+
+     Once we have frame-parameterized frame (and frame-related) commands,
+     the event notification can be moved here, since this function will only
+     be called when the users selected frame is being changed. */
+
+  /* Ensure that symbols for this frame are read in.  Also, determine the
+     source language of this frame, and switch to it if desired.  */
+  if (fi)
+    {
+      s = find_pc_symtab (fi->pc);
+      if (s
+	  && s->language != current_language->la_language
+	  && s->language != language_unknown
+	  && language_mode == language_mode_auto)
+	{
+	  set_language (s->language);
+	}
+    }
+}
+
+
+/* Select frame FI.  Also print the stack frame and show the source if
+   this is the tui version.  */
+static void
+select_and_print_frame (struct frame_info *fi)
+{
+  select_frame (fi);
+  if (fi)
+    {
+      print_stack_frame (fi, frame_relative_level (fi), 1);
+    }
+}
+
+/* Return the symbol-block in which the selected frame is executing.
+   Can return zero under various legitimate circumstances.
+
+   If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
+   code address within the block returned.  We use this to decide
+   which macros are in scope.  */
+
+struct block *
+get_selected_block (CORE_ADDR *addr_in_block)
+{
+  if (!target_has_stack)
+    return 0;
+
+  if (!selected_frame)
+    return get_current_block (addr_in_block);
+  return get_frame_block (selected_frame, addr_in_block);
+}
+
+/* Find a frame a certain number of levels away from FRAME.
+   LEVEL_OFFSET_PTR points to an int containing the number of levels.
+   Positive means go to earlier frames (up); negative, the reverse.
+   The int that contains the number of levels is counted toward
+   zero as the frames for those levels are found.
+   If the top or bottom frame is reached, that frame is returned,
+   but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
+   how much farther the original request asked to go.  */
+
+struct frame_info *
+find_relative_frame (register struct frame_info *frame,
+		     register int *level_offset_ptr)
+{
+  register struct frame_info *prev;
+  register struct frame_info *frame1;
+
+  /* Going up is simple: just do get_prev_frame enough times
+     or until initial frame is reached.  */
+  while (*level_offset_ptr > 0)
+    {
+      prev = get_prev_frame (frame);
+      if (prev == 0)
+	break;
+      (*level_offset_ptr)--;
+      frame = prev;
+    }
+  /* Going down is just as simple.  */
+  if (*level_offset_ptr < 0)
+    {
+      while (*level_offset_ptr < 0)
+	{
+	  frame1 = get_next_frame (frame);
+	  if (!frame1)
+	    break;
+	  frame = frame1;
+	  (*level_offset_ptr)++;
+	}
+    }
+  return frame;
+}
+
+/* The "select_frame" command.  With no arg, NOP.
+   With arg LEVEL_EXP, select the frame at level LEVEL if it is a
+   valid level.  Otherwise, treat level_exp as an address expression
+   and select it.  See parse_frame_specification for more info on proper
+   frame expressions. */
+
+/* ARGSUSED */
+void
+select_frame_command_wrapper (char *level_exp, int from_tty)
+{
+  select_frame_command (level_exp, from_tty);
+}
+
+static void
+select_frame_command (char *level_exp, int from_tty)
+{
+  struct frame_info *frame;
+  int level = frame_relative_level (selected_frame);
+
+  if (!target_has_stack)
+    error ("No stack.");
+
+  frame = parse_frame_specification (level_exp);
+
+  select_frame (frame);
+  if (level != frame_relative_level (selected_frame))
+    selected_frame_level_changed_event (frame_relative_level (selected_frame));
+}
+
+/* The "frame" command.  With no arg, print selected frame briefly.
+   With arg, behaves like select_frame and then prints the selected
+   frame.  */
+
+void
+frame_command (char *level_exp, int from_tty)
+{
+  select_frame_command (level_exp, from_tty);
+  show_and_print_stack_frame (selected_frame,
+			      frame_relative_level (selected_frame), 1);
+}
+
+/* The XDB Compatibility command to print the current frame. */
+
+static void
+current_frame_command (char *level_exp, int from_tty)
+{
+  if (target_has_stack == 0 || selected_frame == 0)
+    error ("No stack.");
+  print_only_stack_frame (selected_frame,
+			  frame_relative_level (selected_frame), 1);
+}
+
+/* Select the frame up one or COUNT stack levels
+   from the previously selected frame, and print it briefly.  */
+
+/* ARGSUSED */
+static void
+up_silently_base (char *count_exp)
+{
+  register struct frame_info *fi;
+  int count = 1, count1;
+  if (count_exp)
+    count = parse_and_eval_long (count_exp);
+  count1 = count;
+
+  if (target_has_stack == 0 || selected_frame == 0)
+    error ("No stack.");
+
+  fi = find_relative_frame (selected_frame, &count1);
+  if (count1 != 0 && count_exp == 0)
+    error ("Initial frame selected; you cannot go up.");
+  select_frame (fi);
+  selected_frame_level_changed_event (frame_relative_level (selected_frame));
+}
+
+static void
+up_silently_command (char *count_exp, int from_tty)
+{
+  up_silently_base (count_exp);
+}
+
+static void
+up_command (char *count_exp, int from_tty)
+{
+  up_silently_base (count_exp);
+  show_and_print_stack_frame (selected_frame,
+			      frame_relative_level (selected_frame), 1);
+}
+
+/* Select the frame down one or COUNT stack levels
+   from the previously selected frame, and print it briefly.  */
+
+/* ARGSUSED */
+static void
+down_silently_base (char *count_exp)
+{
+  register struct frame_info *frame;
+  int count = -1, count1;
+  if (count_exp)
+    count = -parse_and_eval_long (count_exp);
+  count1 = count;
+
+  if (target_has_stack == 0 || selected_frame == 0)
+    error ("No stack.");
+
+  frame = find_relative_frame (selected_frame, &count1);
+  if (count1 != 0 && count_exp == 0)
+    {
+
+      /* We only do this if count_exp is not specified.  That way "down"
+         means to really go down (and let me know if that is
+         impossible), but "down 9999" can be used to mean go all the way
+         down without getting an error.  */
+
+      error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
+    }
+
+  select_frame (frame);
+  selected_frame_level_changed_event (frame_relative_level (selected_frame));
+}
+
+/* ARGSUSED */
+static void
+down_silently_command (char *count_exp, int from_tty)
+{
+  down_silently_base (count_exp);
+}
+
+static void
+down_command (char *count_exp, int from_tty)
+{
+  down_silently_base (count_exp);
+  show_and_print_stack_frame (selected_frame,
+			      frame_relative_level (selected_frame), 1);
+}
+
+void
+return_command_wrapper (char *retval_exp, int from_tty)
+{
+  return_command (retval_exp, from_tty);
+}
+
+static void
+return_command (char *retval_exp, int from_tty)
+{
+  struct symbol *thisfun;
+  CORE_ADDR selected_frame_addr;
+  CORE_ADDR selected_frame_pc;
+  struct frame_info *frame;
+  struct value *return_value = NULL;
+
+  if (selected_frame == NULL)
+    error ("No selected frame.");
+  thisfun = get_frame_function (selected_frame);
+  selected_frame_addr = FRAME_FP (selected_frame);
+  selected_frame_pc = selected_frame->pc;
+
+  /* Compute the return value (if any -- possibly getting errors here).  */
+
+  if (retval_exp)
+    {
+      struct type *return_type = NULL;
+
+      return_value = parse_and_eval (retval_exp);
+
+      /* Cast return value to the return type of the function.  */
+      if (thisfun != NULL)
+	return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
+      if (return_type == NULL)
+	return_type = builtin_type_int;
+      return_value = value_cast (return_type, return_value);
+
+      /* Make sure we have fully evaluated it, since
+         it might live in the stack frame we're about to pop.  */
+      if (VALUE_LAZY (return_value))
+	value_fetch_lazy (return_value);
+    }
+
+  /* If interactive, require confirmation.  */
+
+  if (from_tty)
+    {
+      if (thisfun != 0)
+	{
+	  if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun)))
+	    {
+	      error ("Not confirmed.");
+	      /* NOTREACHED */
+	    }
+	}
+      else if (!query ("Make selected stack frame return now? "))
+	error ("Not confirmed.");
+    }
+
+  /* Do the real work.  Pop until the specified frame is current.  We
+     use this method because the selected_frame is not valid after
+     a POP_FRAME.  The pc comparison makes this work even if the
+     selected frame shares its fp with another frame.  */
+
+  while (selected_frame_addr != (frame = get_current_frame ())->frame
+	 || selected_frame_pc != frame->pc)
+    POP_FRAME;
+
+  /* Then pop that frame.  */
+
+  POP_FRAME;
+
+  /* Compute the return value (if any) and store in the place
+     for return values.  */
+
+  if (retval_exp)
+    set_return_value (return_value);
+
+  /* If we are at the end of a call dummy now, pop the dummy frame too.  */
+
+  if (CALL_DUMMY_HAS_COMPLETED (read_pc(), read_sp (),
+				FRAME_FP (get_current_frame ())))
+    POP_FRAME;
+
+  /* If interactive, print the frame that is now current.  */
+
+  if (from_tty)
+    frame_command ("0", 1);
+  else
+    select_frame_command ("0", 0);
+}
+
+/* Sets the scope to input function name, provided that the
+   function is within the current stack frame */
+
+struct function_bounds
+{
+  CORE_ADDR low, high;
+};
+
+static void func_command (char *arg, int from_tty);
+static void
+func_command (char *arg, int from_tty)
+{
+  struct frame_info *fp;
+  int found = 0;
+  struct symtabs_and_lines sals;
+  int i;
+  int level = 1;
+  struct function_bounds *func_bounds = (struct function_bounds *) NULL;
+
+  if (arg != (char *) NULL)
+    return;
+
+  fp = parse_frame_specification ("0");
+  sals = decode_line_spec (arg, 1);
+  func_bounds = (struct function_bounds *) xmalloc (
+			      sizeof (struct function_bounds) * sals.nelts);
+  for (i = 0; (i < sals.nelts && !found); i++)
+    {
+      if (sals.sals[i].pc == (CORE_ADDR) 0 ||
+	  find_pc_partial_function (sals.sals[i].pc,
+				    (char **) NULL,
+				    &func_bounds[i].low,
+				    &func_bounds[i].high) == 0)
+	{
+	  func_bounds[i].low =
+	    func_bounds[i].high = (CORE_ADDR) NULL;
+	}
+    }
+
+  do
+    {
+      for (i = 0; (i < sals.nelts && !found); i++)
+	found = (fp->pc >= func_bounds[i].low &&
+		 fp->pc < func_bounds[i].high);
+      if (!found)
+	{
+	  level = 1;
+	  fp = find_relative_frame (fp, &level);
+	}
+    }
+  while (!found && level == 0);
+
+  if (func_bounds)
+    xfree (func_bounds);
+
+  if (!found)
+    printf_filtered ("'%s' not within current stack frame.\n", arg);
+  else if (fp != selected_frame)
+    select_and_print_frame (fp);
+}
+
+/* Gets the language of the current frame.  */
+
+enum language
+get_frame_language (void)
+{
+  register struct symtab *s;
+  enum language flang;		/* The language of the current frame */
+
+  if (selected_frame)
+    {
+      s = find_pc_symtab (selected_frame->pc);
+      if (s)
+	flang = s->language;
+      else
+	flang = language_unknown;
+    }
+  else
+    flang = language_unknown;
+
+  return flang;
+}
+
+void
+_initialize_stack (void)
+{
+#if 0
+  backtrace_limit = 30;
+#endif
+
+  add_com ("return", class_stack, return_command,
+	   "Make selected stack frame return to its caller.\n\
+Control remains in the debugger, but when you continue\n\
+execution will resume in the frame above the one now selected.\n\
+If an argument is given, it is an expression for the value to return.");
+
+  add_com ("up", class_stack, up_command,
+	   "Select and print stack frame that called this one.\n\
+An argument says how many frames up to go.");
+  add_com ("up-silently", class_support, up_silently_command,
+	   "Same as the `up' command, but does not print anything.\n\
+This is useful in command scripts.");
+
+  add_com ("down", class_stack, down_command,
+	   "Select and print stack frame called by this one.\n\
+An argument says how many frames down to go.");
+  add_com_alias ("do", "down", class_stack, 1);
+  add_com_alias ("dow", "down", class_stack, 1);
+  add_com ("down-silently", class_support, down_silently_command,
+	   "Same as the `down' command, but does not print anything.\n\
+This is useful in command scripts.");
+
+  add_com ("frame", class_stack, frame_command,
+	   "Select and print a stack frame.\n\
+With no argument, print the selected stack frame.  (See also \"info frame\").\n\
+An argument specifies the frame to select.\n\
+It can be a stack frame number or the address of the frame.\n\
+With argument, nothing is printed if input is coming from\n\
+a command file or a user-defined command.");
+
+  add_com_alias ("f", "frame", class_stack, 1);
+
+  if (xdb_commands)
+    {
+      add_com ("L", class_stack, current_frame_command,
+	       "Print the current stack frame.\n");
+      add_com_alias ("V", "frame", class_stack, 1);
+    }
+  add_com ("select-frame", class_stack, select_frame_command,
+	   "Select a stack frame without printing anything.\n\
+An argument specifies the frame to select.\n\
+It can be a stack frame number or the address of the frame.\n");
+
+  add_com ("backtrace", class_stack, backtrace_command,
+	   "Print backtrace of all stack frames, or innermost COUNT frames.\n\
+With a negative argument, print outermost -COUNT frames.\n\
+Use of the 'full' qualifier also prints the values of the local variables.\n");
+  add_com_alias ("bt", "backtrace", class_stack, 0);
+  if (xdb_commands)
+    {
+      add_com_alias ("t", "backtrace", class_stack, 0);
+      add_com ("T", class_stack, backtrace_full_command,
+	       "Print backtrace of all stack frames, or innermost COUNT frames \n\
+and the values of the local variables.\n\
+With a negative argument, print outermost -COUNT frames.\n\
+Usage: T <count>\n");
+    }
+
+  add_com_alias ("where", "backtrace", class_alias, 0);
+  add_info ("stack", backtrace_command,
+	    "Backtrace of the stack, or innermost COUNT frames.");
+  add_info_alias ("s", "stack", 1);
+  add_info ("frame", frame_info,
+	    "All about selected stack frame, or frame at ADDR.");
+  add_info_alias ("f", "frame", 1);
+  add_info ("locals", locals_info,
+	    "Local variables of current stack frame.");
+  add_info ("args", args_info,
+	    "Argument variables of current stack frame.");
+  if (xdb_commands)
+    add_com ("l", class_info, args_plus_locals_info,
+	     "Argument and local variables of current stack frame.");
+
+  if (dbx_commands)
+    add_com ("func", class_stack, func_command,
+      "Select the stack frame that contains <func>.\nUsage: func <name>\n");
+
+  add_info ("catch", catch_info,
+	    "Exceptions that can be caught in the current stack frame.");
+
+#if 0
+  add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command,
+  "Specify maximum number of frames for \"backtrace\" to print by default.",
+	   &setlist);
+  add_info ("backtrace-limit", backtrace_limit_info,
+     "The maximum number of frames for \"backtrace\" to print by default.");
+#endif
+}
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
new file mode 100644
index 0000000..2d12f31
--- /dev/null
+++ b/gdb/tracepoint.c
@@ -0,0 +1,2812 @@
+/* Tracing functionality for remote targets in custom GDB protocol
+
+   Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software
+   Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "symtab.h"
+#include "frame.h"
+#include "gdbtypes.h"
+#include "expression.h"
+#include "gdbcmd.h"
+#include "value.h"
+#include "target.h"
+#include "language.h"
+#include "gdb_string.h"
+#include "inferior.h"
+#include "tracepoint.h"
+#include "remote.h"
+#include "linespec.h"
+#include "regcache.h"
+#include "completer.h"
+#include "gdb-events.h"
+
+#include "ax.h"
+#include "ax-gdb.h"
+
+/* readline include files */
+#include <readline/readline.h>
+#include <readline/history.h>
+
+/* readline defines this.  */
+#undef savestring
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+/* maximum length of an agent aexpression.
+   this accounts for the fact that packets are limited to 400 bytes
+   (which includes everything -- including the checksum), and assumes
+   the worst case of maximum length for each of the pieces of a
+   continuation packet.
+
+   NOTE: expressions get mem2hex'ed otherwise this would be twice as
+   large.  (400 - 31)/2 == 184 */
+#define MAX_AGENT_EXPR_LEN	184
+
+
+extern void (*readline_begin_hook) (char *, ...);
+extern char *(*readline_hook) (char *);
+extern void (*readline_end_hook) (void);
+extern void x_command (char *, int);
+extern int addressprint;	/* Print machine addresses? */
+
+/* GDB commands implemented in other modules:
+ */  
+
+extern void output_command (char *, int);
+extern void registers_info (char *, int);
+extern void args_info (char *, int);
+extern void locals_info (char *, int);
+
+
+/* If this definition isn't overridden by the header files, assume
+   that isatty and fileno exist on this system.  */
+#ifndef ISATTY
+#define ISATTY(FP)	(isatty (fileno (FP)))
+#endif
+
+/* 
+   Tracepoint.c:
+
+   This module defines the following debugger commands:
+   trace            : set a tracepoint on a function, line, or address.
+   info trace       : list all debugger-defined tracepoints.
+   delete trace     : delete one or more tracepoints.
+   enable trace     : enable one or more tracepoints.
+   disable trace    : disable one or more tracepoints.
+   actions          : specify actions to be taken at a tracepoint.
+   passcount        : specify a pass count for a tracepoint.
+   tstart           : start a trace experiment.
+   tstop            : stop a trace experiment.
+   tstatus          : query the status of a trace experiment.
+   tfind            : find a trace frame in the trace buffer.
+   tdump            : print everything collected at the current tracepoint.
+   save-tracepoints : write tracepoint setup into a file.
+
+   This module defines the following user-visible debugger variables:
+   $trace_frame : sequence number of trace frame currently being debugged.
+   $trace_line  : source line of trace frame currently being debugged.
+   $trace_file  : source file of trace frame currently being debugged.
+   $tracepoint  : tracepoint number of trace frame currently being debugged.
+ */
+
+
+/* ======= Important global variables: ======= */
+
+/* Chain of all tracepoints defined.  */
+struct tracepoint *tracepoint_chain;
+
+/* Number of last tracepoint made.  */
+static int tracepoint_count;
+
+/* Number of last traceframe collected.  */
+static int traceframe_number;
+
+/* Tracepoint for last traceframe collected.  */
+static int tracepoint_number;
+
+/* Symbol for function for last traceframe collected */
+static struct symbol *traceframe_fun;
+
+/* Symtab and line for last traceframe collected */
+static struct symtab_and_line traceframe_sal;
+
+/* Tracing command lists */
+static struct cmd_list_element *tfindlist;
+
+/* ======= Important command functions: ======= */
+static void trace_command (char *, int);
+static void tracepoints_info (char *, int);
+static void delete_trace_command (char *, int);
+static void enable_trace_command (char *, int);
+static void disable_trace_command (char *, int);
+static void trace_pass_command (char *, int);
+static void trace_actions_command (char *, int);
+static void trace_start_command (char *, int);
+static void trace_stop_command (char *, int);
+static void trace_status_command (char *, int);
+static void trace_find_command (char *, int);
+static void trace_find_pc_command (char *, int);
+static void trace_find_tracepoint_command (char *, int);
+static void trace_find_line_command (char *, int);
+static void trace_find_range_command (char *, int);
+static void trace_find_outside_command (char *, int);
+static void tracepoint_save_command (char *, int);
+static void trace_dump_command (char *, int);
+
+/* support routines */
+static void trace_mention (struct tracepoint *);
+
+struct collection_list;
+static void add_aexpr (struct collection_list *, struct agent_expr *);
+static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
+static void add_register (struct collection_list *collection,
+			  unsigned int regno);
+static struct cleanup *make_cleanup_free_actions (struct tracepoint *t);
+static void free_actions_list (char **actions_list);
+static void free_actions_list_cleanup_wrapper (void *);
+
+extern void _initialize_tracepoint (void);
+
+/* Utility: returns true if "target remote" */
+static int
+target_is_remote (void)
+{
+  if (current_target.to_shortname &&
+      strcmp (current_target.to_shortname, "remote") == 0)
+    return 1;
+  else
+    return 0;
+}
+
+/* Utility: generate error from an incoming stub packet.  */
+static void
+trace_error (char *buf)
+{
+  if (*buf++ != 'E')
+    return;			/* not an error msg */
+  switch (*buf)
+    {
+    case '1':			/* malformed packet error */
+      if (*++buf == '0')	/*   general case: */
+	error ("tracepoint.c: error in outgoing packet.");
+      else
+	error ("tracepoint.c: error in outgoing packet at field #%ld.",
+	       strtol (buf, NULL, 16));
+    case '2':
+      error ("trace API error 0x%s.", ++buf);
+    default:
+      error ("Target returns error code '%s'.", buf);
+    }
+}
+
+/* Utility: wait for reply from stub, while accepting "O" packets */
+static char *
+remote_get_noisy_reply (char *buf,
+			long sizeof_buf)
+{
+  do				/* loop on reply from remote stub */
+    {
+      QUIT;			/* allow user to bail out with ^C */
+      getpkt (buf, sizeof_buf, 0);
+      if (buf[0] == 0)
+	error ("Target does not support this command.");
+      else if (buf[0] == 'E')
+	trace_error (buf);
+      else if (buf[0] == 'O' &&
+	       buf[1] != 'K')
+	remote_console_output (buf + 1);	/* 'O' message from stub */
+      else
+	return buf;		/* here's the actual reply */
+    }
+  while (1);
+}
+
+/* Set tracepoint count to NUM.  */
+static void
+set_tracepoint_count (int num)
+{
+  tracepoint_count = num;
+  set_internalvar (lookup_internalvar ("tpnum"),
+		   value_from_longest (builtin_type_int, (LONGEST) num));
+}
+
+/* Set traceframe number to NUM.  */
+static void
+set_traceframe_num (int num)
+{
+  traceframe_number = num;
+  set_internalvar (lookup_internalvar ("trace_frame"),
+		   value_from_longest (builtin_type_int, (LONGEST) num));
+}
+
+/* Set tracepoint number to NUM.  */
+static void
+set_tracepoint_num (int num)
+{
+  tracepoint_number = num;
+  set_internalvar (lookup_internalvar ("tracepoint"),
+		   value_from_longest (builtin_type_int, (LONGEST) num));
+}
+
+/* Set externally visible debug variables for querying/printing
+   the traceframe context (line, function, file) */
+
+static void
+set_traceframe_context (CORE_ADDR trace_pc)
+{
+  static struct type *func_string, *file_string;
+  static struct type *func_range, *file_range;
+  struct value *func_val;
+  struct value *file_val;
+  static struct type *charstar;
+  int len;
+
+  if (charstar == (struct type *) NULL)
+    charstar = lookup_pointer_type (builtin_type_char);
+
+  if (trace_pc == -1)		/* cease debugging any trace buffers */
+    {
+      traceframe_fun = 0;
+      traceframe_sal.pc = traceframe_sal.line = 0;
+      traceframe_sal.symtab = NULL;
+      set_internalvar (lookup_internalvar ("trace_func"),
+		       value_from_pointer (charstar, (LONGEST) 0));
+      set_internalvar (lookup_internalvar ("trace_file"),
+		       value_from_pointer (charstar, (LONGEST) 0));
+      set_internalvar (lookup_internalvar ("trace_line"),
+		       value_from_pointer (builtin_type_int, (LONGEST) - 1));
+      return;
+    }
+
+  /* save as globals for internal use */
+  traceframe_sal = find_pc_line (trace_pc, 0);
+  traceframe_fun = find_pc_function (trace_pc);
+
+  /* save linenumber as "$trace_line", a debugger variable visible to users */
+  set_internalvar (lookup_internalvar ("trace_line"),
+		   value_from_longest (builtin_type_int,
+				       (LONGEST) traceframe_sal.line));
+
+  /* save func name as "$trace_func", a debugger variable visible to users */
+  if (traceframe_fun == NULL ||
+      SYMBOL_NAME (traceframe_fun) == NULL)
+    set_internalvar (lookup_internalvar ("trace_func"),
+		     value_from_pointer (charstar, (LONGEST) 0));
+  else
+    {
+      len = strlen (SYMBOL_NAME (traceframe_fun));
+      func_range = create_range_type (func_range,
+				      builtin_type_int, 0, len - 1);
+      func_string = create_array_type (func_string,
+				       builtin_type_char, func_range);
+      func_val = allocate_value (func_string);
+      VALUE_TYPE (func_val) = func_string;
+      memcpy (VALUE_CONTENTS_RAW (func_val),
+	      SYMBOL_NAME (traceframe_fun),
+	      len);
+      func_val->modifiable = 0;
+      set_internalvar (lookup_internalvar ("trace_func"), func_val);
+    }
+
+  /* save file name as "$trace_file", a debugger variable visible to users */
+  if (traceframe_sal.symtab == NULL ||
+      traceframe_sal.symtab->filename == NULL)
+    set_internalvar (lookup_internalvar ("trace_file"),
+		     value_from_pointer (charstar, (LONGEST) 0));
+  else
+    {
+      len = strlen (traceframe_sal.symtab->filename);
+      file_range = create_range_type (file_range,
+				      builtin_type_int, 0, len - 1);
+      file_string = create_array_type (file_string,
+				       builtin_type_char, file_range);
+      file_val = allocate_value (file_string);
+      VALUE_TYPE (file_val) = file_string;
+      memcpy (VALUE_CONTENTS_RAW (file_val),
+	      traceframe_sal.symtab->filename,
+	      len);
+      file_val->modifiable = 0;
+      set_internalvar (lookup_internalvar ("trace_file"), file_val);
+    }
+}
+
+/* Low level routine to set a tracepoint.
+   Returns the tracepoint object so caller can set other things.
+   Does not set the tracepoint number!
+   Does not print anything.
+
+   ==> This routine should not be called if there is a chance of later
+   error(); otherwise it leaves a bogus tracepoint on the chain.  Validate
+   your arguments BEFORE calling this routine!  */
+
+static struct tracepoint *
+set_raw_tracepoint (struct symtab_and_line sal)
+{
+  register struct tracepoint *t, *tc;
+  struct cleanup *old_chain;
+
+  t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
+  old_chain = make_cleanup (xfree, t);
+  memset (t, 0, sizeof (*t));
+  t->address = sal.pc;
+  if (sal.symtab == NULL)
+    t->source_file = NULL;
+  else
+    t->source_file = savestring (sal.symtab->filename,
+				 strlen (sal.symtab->filename));
+
+  t->section = sal.section;
+  t->language = current_language->la_language;
+  t->input_radix = input_radix;
+  t->line_number = sal.line;
+  t->enabled_p = 1;
+  t->next = 0;
+  t->step_count = 0;
+  t->pass_count = 0;
+  t->addr_string = NULL;
+
+  /* Add this tracepoint to the end of the chain
+     so that a list of tracepoints will come out in order
+     of increasing numbers.  */
+
+  tc = tracepoint_chain;
+  if (tc == 0)
+    tracepoint_chain = t;
+  else
+    {
+      while (tc->next)
+	tc = tc->next;
+      tc->next = t;
+    }
+  discard_cleanups (old_chain);
+  return t;
+}
+
+/* Set a tracepoint according to ARG (function, linenum or *address) */
+static void
+trace_command (char *arg, int from_tty)
+{
+  char **canonical = (char **) NULL;
+  struct symtabs_and_lines sals;
+  struct symtab_and_line sal;
+  struct tracepoint *t;
+  char *addr_start = 0, *addr_end = 0;
+  int i;
+
+  if (!arg || !*arg)
+    error ("trace command requires an argument");
+
+  if (from_tty && info_verbose)
+    printf_filtered ("TRACE %s\n", arg);
+
+  addr_start = arg;
+  sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical);
+  addr_end = arg;
+  if (!sals.nelts)
+    return;			/* ??? Presumably decode_line_1 has already warned? */
+
+  /* Resolve all line numbers to PC's */
+  for (i = 0; i < sals.nelts; i++)
+    resolve_sal_pc (&sals.sals[i]);
+
+  /* Now set all the tracepoints.  */
+  for (i = 0; i < sals.nelts; i++)
+    {
+      sal = sals.sals[i];
+
+      t = set_raw_tracepoint (sal);
+      set_tracepoint_count (tracepoint_count + 1);
+      t->number = tracepoint_count;
+
+      /* If a canonical line spec is needed use that instead of the
+         command string.  */
+      if (canonical != (char **) NULL && canonical[i] != NULL)
+	t->addr_string = canonical[i];
+      else if (addr_start)
+	t->addr_string = savestring (addr_start, addr_end - addr_start);
+
+      trace_mention (t);
+    }
+
+  if (sals.nelts > 1)
+    {
+      printf_filtered ("Multiple tracepoints were set.\n");
+      printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
+    }
+}
+
+/* Tell the user we have just set a tracepoint TP. */
+
+static void
+trace_mention (struct tracepoint *tp)
+{
+  printf_filtered ("Tracepoint %d", tp->number);
+
+  if (addressprint || (tp->source_file == NULL))
+    {
+      printf_filtered (" at ");
+      print_address_numeric (tp->address, 1, gdb_stdout);
+    }
+  if (tp->source_file)
+    printf_filtered (": file %s, line %d.",
+		     tp->source_file, tp->line_number);
+
+  printf_filtered ("\n");
+}
+
+/* Print information on tracepoint number TPNUM_EXP, or all if omitted.  */
+
+static void
+tracepoints_info (char *tpnum_exp, int from_tty)
+{
+  struct tracepoint *t;
+  struct action_line *action;
+  int found_a_tracepoint = 0;
+  char wrap_indent[80];
+  struct symbol *sym;
+  int tpnum = -1;
+
+  if (tpnum_exp)
+    tpnum = parse_and_eval_long (tpnum_exp);
+
+  ALL_TRACEPOINTS (t)
+    if (tpnum == -1 || tpnum == t->number)
+    {
+      extern int addressprint;	/* print machine addresses? */
+
+      if (!found_a_tracepoint++)
+	{
+	  printf_filtered ("Num Enb ");
+	  if (addressprint)
+	    {
+	      if (TARGET_ADDR_BIT <= 32)
+		printf_filtered ("Address    ");
+	      else
+		printf_filtered ("Address            ");
+	    }
+	  printf_filtered ("PassC StepC What\n");
+	}
+      strcpy (wrap_indent, "                           ");
+      if (addressprint)
+	{
+	  if (TARGET_ADDR_BIT <= 32)
+	    strcat (wrap_indent, "           ");
+	  else
+	    strcat (wrap_indent, "                   ");
+	}
+
+      printf_filtered ("%-3d %-3s ", t->number,
+		       t->enabled_p ? "y" : "n");
+      if (addressprint)
+	{
+	  char *tmp;
+
+	  if (TARGET_ADDR_BIT <= 32)
+	    tmp = local_hex_string_custom (t->address
+					   & (CORE_ADDR) 0xffffffff, 
+					   "08l");
+	  else
+	    tmp = local_hex_string_custom (t->address, "016l");
+
+	  printf_filtered ("%s ", tmp);
+	}
+      printf_filtered ("%-5d %-5ld ", t->pass_count, t->step_count);
+
+      if (t->source_file)
+	{
+	  sym = find_pc_sect_function (t->address, t->section);
+	  if (sym)
+	    {
+	      fputs_filtered ("in ", gdb_stdout);
+	      fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
+	      wrap_here (wrap_indent);
+	      fputs_filtered (" at ", gdb_stdout);
+	    }
+	  fputs_filtered (t->source_file, gdb_stdout);
+	  printf_filtered (":%d", t->line_number);
+	}
+      else
+	print_address_symbolic (t->address, gdb_stdout, demangle, " ");
+
+      printf_filtered ("\n");
+      if (t->actions)
+	{
+	  printf_filtered ("  Actions for tracepoint %d: \n", t->number);
+	  for (action = t->actions; action; action = action->next)
+	    {
+	      printf_filtered ("\t%s\n", action->action);
+	    }
+	}
+    }
+  if (!found_a_tracepoint)
+    {
+      if (tpnum == -1)
+	printf_filtered ("No tracepoints.\n");
+      else
+	printf_filtered ("No tracepoint number %d.\n", tpnum);
+    }
+}
+
+/* Optimization: the code to parse an enable, disable, or delete TP command
+   is virtually identical except for whether it performs an enable, disable,
+   or delete.  Therefore I've combined them into one function with an opcode.
+ */
+enum tracepoint_opcode
+{
+  enable_op,
+  disable_op,
+  delete_op
+};
+
+/* This function implements enable, disable and delete commands. */
+static void
+tracepoint_operation (struct tracepoint *t, int from_tty,
+		      enum tracepoint_opcode opcode)
+{
+  struct tracepoint *t2;
+
+  if (t == NULL)	/* no tracepoint operand */
+    return;
+
+  switch (opcode)
+    {
+    case enable_op:
+      t->enabled_p = 1;
+      tracepoint_modify_event (t->number);
+      break;
+    case disable_op:
+      t->enabled_p = 0;
+      tracepoint_modify_event (t->number);
+      break;
+    case delete_op:
+      if (tracepoint_chain == t)
+	tracepoint_chain = t->next;
+
+      ALL_TRACEPOINTS (t2)
+	if (t2->next == t)
+	{
+	  tracepoint_delete_event (t2->number);
+	  t2->next = t->next;
+	  break;
+	}
+
+      if (t->addr_string)
+	xfree (t->addr_string);
+      if (t->source_file)
+	xfree (t->source_file);
+      if (t->actions)
+	free_actions (t);
+
+      xfree (t);
+      break;
+    }
+}
+
+/* Utility: parse a tracepoint number and look it up in the list.
+   If MULTI_P is true, there might be a range of tracepoints in ARG.
+   if OPTIONAL_P is true, then if the argument is missing, the most
+   recent tracepoint (tracepoint_count) is returned.  */
+struct tracepoint *
+get_tracepoint_by_number (char **arg, int multi_p, int optional_p)
+{
+  struct tracepoint *t;
+  int tpnum;
+  char *instring = arg == NULL ? NULL : *arg;
+
+  if (arg == NULL || *arg == NULL || ! **arg)
+    {
+      if (optional_p)
+	tpnum = tracepoint_count;
+      else
+	error_no_arg ("tracepoint number");
+    }
+  else
+    tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
+
+  if (tpnum <= 0)
+    {
+      if (instring && *instring)
+	printf_filtered ("bad tracepoint number at or near '%s'\n", instring);
+      else
+	printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
+      return NULL;
+    }
+
+  ALL_TRACEPOINTS (t)
+    if (t->number == tpnum)
+    {
+      return t;
+    }
+
+  /* FIXME: if we are in the middle of a range we don't want to give
+     a message.  The current interface to get_number_or_range doesn't
+     allow us to discover this.  */
+  printf_unfiltered ("No tracepoint number %d.\n", tpnum);
+  return NULL;
+}
+
+/* Utility: parse a list of tracepoint numbers, and call a func for each. */
+static void
+map_args_over_tracepoints (char *args, int from_tty,
+			   enum tracepoint_opcode opcode)
+{
+  struct tracepoint *t, *tmp;
+
+  if (args == 0 || *args == 0)	/* do them all */
+    ALL_TRACEPOINTS_SAFE (t, tmp)
+      tracepoint_operation (t, from_tty, opcode);
+  else
+    while (*args)
+      {
+	QUIT;			/* give user option to bail out with ^C */
+	t = get_tracepoint_by_number (&args, 1, 0);
+	tracepoint_operation (t, from_tty, opcode);
+	while (*args == ' ' || *args == '\t')
+	  args++;
+      }
+}
+
+/* The 'enable trace' command enables tracepoints.  Not supported by all targets.  */
+static void
+enable_trace_command (char *args, int from_tty)
+{
+  dont_repeat ();
+  map_args_over_tracepoints (args, from_tty, enable_op);
+}
+
+/* The 'disable trace' command enables tracepoints.  Not supported by all targets.  */
+static void
+disable_trace_command (char *args, int from_tty)
+{
+  dont_repeat ();
+  map_args_over_tracepoints (args, from_tty, disable_op);
+}
+
+/* Remove a tracepoint (or all if no argument) */
+static void
+delete_trace_command (char *args, int from_tty)
+{
+  dont_repeat ();
+  if (!args || !*args)		/* No args implies all tracepoints; */
+    if (from_tty)		/* confirm only if from_tty... */
+      if (tracepoint_chain)	/* and if there are tracepoints to delete! */
+	if (!query ("Delete all tracepoints? "))
+	  return;
+
+  map_args_over_tracepoints (args, from_tty, delete_op);
+}
+
+/* Set passcount for tracepoint.
+
+   First command argument is passcount, second is tracepoint number.
+   If tracepoint number omitted, apply to most recently defined.
+   Also accepts special argument "all".  */
+
+static void
+trace_pass_command (char *args, int from_tty)
+{
+  struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
+  unsigned int count;
+  int all = 0;
+
+  if (args == 0 || *args == 0)
+    error ("passcount command requires an argument (count + optional TP num)");
+
+  count = strtoul (args, &args, 10);	/* count comes first, then TP num */
+
+  while (*args && isspace ((int) *args))
+    args++;
+
+  if (*args && strncasecmp (args, "all", 3) == 0)
+    {
+      args += 3;			/* skip special argument "all" */
+      all = 1;
+      if (*args)
+	error ("Junk at end of arguments.");
+    }
+  else
+    t1 = get_tracepoint_by_number (&args, 1, 1);
+
+  do
+    {
+      if (t1)
+	{
+	  ALL_TRACEPOINTS (t2)
+	    if (t1 == (struct tracepoint *) -1 || t1 == t2)
+	      {
+		t2->pass_count = count;
+		tracepoint_modify_event (t2->number);
+		if (from_tty)
+		  printf_filtered ("Setting tracepoint %d's passcount to %d\n",
+				   t2->number, count);
+	      }
+	  if (! all && *args)
+	    t1 = get_tracepoint_by_number (&args, 1, 0);
+	}
+    }
+  while (*args);
+}
+
+/* ACTIONS functions: */
+
+/* Prototypes for action-parsing utility commands  */
+static void read_actions (struct tracepoint *);
+
+/* The three functions:
+   collect_pseudocommand, 
+   while_stepping_pseudocommand, and 
+   end_actions_pseudocommand
+   are placeholders for "commands" that are actually ONLY to be used
+   within a tracepoint action list.  If the actual function is ever called,
+   it means that somebody issued the "command" at the top level,
+   which is always an error.  */
+
+static void
+end_actions_pseudocommand (char *args, int from_tty)
+{
+  error ("This command cannot be used at the top level.");
+}
+
+static void
+while_stepping_pseudocommand (char *args, int from_tty)
+{
+  error ("This command can only be used in a tracepoint actions list.");
+}
+
+static void
+collect_pseudocommand (char *args, int from_tty)
+{
+  error ("This command can only be used in a tracepoint actions list.");
+}
+
+/* Enter a list of actions for a tracepoint.  */
+static void
+trace_actions_command (char *args, int from_tty)
+{
+  struct tracepoint *t;
+  char tmpbuf[128];
+  char *end_msg = "End with a line saying just \"end\".";
+
+  t = get_tracepoint_by_number (&args, 0, 1);
+  if (t)
+    {
+      sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
+	       t->number);
+
+      if (from_tty)
+	{
+	  if (readline_begin_hook)
+	    (*readline_begin_hook) ("%s  %s\n", tmpbuf, end_msg);
+	  else if (input_from_terminal_p ())
+	    printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
+	}
+
+      free_actions (t);
+      t->step_count = 0;	/* read_actions may set this */
+      read_actions (t);
+
+      if (readline_end_hook)
+	(*readline_end_hook) ();
+      /* tracepoints_changed () */
+    }
+  /* else just return */
+}
+
+/* worker function */
+static void
+read_actions (struct tracepoint *t)
+{
+  char *line;
+  char *prompt1 = "> ", *prompt2 = "  > ";
+  char *prompt = prompt1;
+  enum actionline_type linetype;
+  extern FILE *instream;
+  struct action_line *next = NULL, *temp;
+  struct cleanup *old_chain;
+
+  /* Control-C quits instantly if typed while in this loop
+     since it should not wait until the user types a newline.  */
+  immediate_quit++;
+  /* FIXME: kettenis/20010823: Something is wrong here.  In this file
+     STOP_SIGNAL is never defined.  So this code has been left out, at
+     least for quite a while now.  Replacing STOP_SIGNAL with SIGTSTP
+     leads to compilation failures since the variable job_control
+     isn't declared.  Leave this alone for now.  */
+#ifdef STOP_SIGNAL
+  if (job_control)
+    {
+      if (event_loop_p)
+	signal (STOP_SIGNAL, handle_stop_sig);
+      else
+	signal (STOP_SIGNAL, stop_sig);
+    }
+#endif
+  old_chain = make_cleanup_free_actions (t);
+  while (1)
+    {
+      /* Make sure that all output has been output.  Some machines may let
+         you get away with leaving out some of the gdb_flush, but not all.  */
+      wrap_here ("");
+      gdb_flush (gdb_stdout);
+      gdb_flush (gdb_stderr);
+
+      if (readline_hook && instream == NULL)
+	line = (*readline_hook) (prompt);
+      else if (instream == stdin && ISATTY (instream))
+	{
+	  line = gdb_readline_wrapper (prompt);
+	  if (line && *line)	/* add it to command history */
+	    add_history (line);
+	}
+      else
+	line = gdb_readline (0);
+
+      linetype = validate_actionline (&line, t);
+      if (linetype == BADLINE)
+	continue;		/* already warned -- collect another line */
+
+      temp = xmalloc (sizeof (struct action_line));
+      temp->next = NULL;
+      temp->action = line;
+
+      if (next == NULL)		/* first action for this tracepoint? */
+	t->actions = next = temp;
+      else
+	{
+	  next->next = temp;
+	  next = temp;
+	}
+
+      if (linetype == STEPPING)	/* begin "while-stepping" */
+	{
+	  if (prompt == prompt2)
+	    {
+	      warning ("Already processing 'while-stepping'");
+	      continue;
+	    }
+	  else
+	    prompt = prompt2;	/* change prompt for stepping actions */
+	}
+      else if (linetype == END)
+	{
+	  if (prompt == prompt2)
+	    {
+	      prompt = prompt1;	/* end of single-stepping actions */
+	    }
+	  else
+	    {			/* end of actions */
+	      if (t->actions->next == NULL)
+		{
+		  /* an "end" all by itself with no other actions means
+		     this tracepoint has no actions.  Discard empty list. */
+		  free_actions (t);
+		}
+	      break;
+	    }
+	}
+    }
+#ifdef STOP_SIGNAL
+  if (job_control)
+    signal (STOP_SIGNAL, SIG_DFL);
+#endif
+  immediate_quit--;
+  discard_cleanups (old_chain);
+}
+
+/* worker function */
+enum actionline_type
+validate_actionline (char **line, struct tracepoint *t)
+{
+  struct cmd_list_element *c;
+  struct expression *exp = NULL;
+  struct cleanup *old_chain = NULL;
+  char *p;
+
+  for (p = *line; isspace ((int) *p);)
+    p++;
+
+  /* symbol lookup etc. */
+  if (*p == '\0')		/* empty line: just prompt for another line. */
+    return BADLINE;
+
+  if (*p == '#')		/* comment line */
+    return GENERIC;
+
+  c = lookup_cmd (&p, cmdlist, "", -1, 1);
+  if (c == 0)
+    {
+      warning ("'%s' is not an action that I know, or is ambiguous.", p);
+      return BADLINE;
+    }
+
+  if (cmd_cfunc_eq (c, collect_pseudocommand))
+    {
+      struct agent_expr *aexpr;
+      struct agent_reqs areqs;
+
+      do
+	{			/* repeat over a comma-separated list */
+	  QUIT;			/* allow user to bail out with ^C */
+	  while (isspace ((int) *p))
+	    p++;
+
+	  if (*p == '$')	/* look for special pseudo-symbols */
+	    {
+	      if ((0 == strncasecmp ("reg", p + 1, 3)) ||
+		  (0 == strncasecmp ("arg", p + 1, 3)) ||
+		  (0 == strncasecmp ("loc", p + 1, 3)))
+		{
+		  p = strchr (p, ',');
+		  continue;
+		}
+	      /* else fall thru, treat p as an expression and parse it! */
+	    }
+	  exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
+	  old_chain = make_cleanup (free_current_contents, &exp);
+
+	  if (exp->elts[0].opcode == OP_VAR_VALUE)
+	    {
+	      if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
+		{
+		  warning ("constant %s (value %ld) will not be collected.",
+			   SYMBOL_NAME (exp->elts[2].symbol),
+			   SYMBOL_VALUE (exp->elts[2].symbol));
+		  return BADLINE;
+		}
+	      else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
+		{
+		  warning ("%s is optimized away and cannot be collected.",
+			   SYMBOL_NAME (exp->elts[2].symbol));
+		  return BADLINE;
+		}
+	    }
+
+	  /* we have something to collect, make sure that the expr to
+	     bytecode translator can handle it and that it's not too long */
+	  aexpr = gen_trace_for_expr (t->address, exp);
+	  make_cleanup_free_agent_expr (aexpr);
+
+	  if (aexpr->len > MAX_AGENT_EXPR_LEN)
+	    error ("expression too complicated, try simplifying");
+
+	  ax_reqs (aexpr, &areqs);
+	  (void) make_cleanup (xfree, areqs.reg_mask);
+
+	  if (areqs.flaw != agent_flaw_none)
+	    error ("malformed expression");
+
+	  if (areqs.min_height < 0)
+	    error ("gdb: Internal error: expression has min height < 0");
+
+	  if (areqs.max_height > 20)
+	    error ("expression too complicated, try simplifying");
+
+	  do_cleanups (old_chain);
+	}
+      while (p && *p++ == ',');
+      return GENERIC;
+    }
+  else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
+    {
+      char *steparg;		/* in case warning is necessary */
+
+      while (isspace ((int) *p))
+	p++;
+      steparg = p;
+
+      if (*p == '\0' ||
+	  (t->step_count = strtol (p, &p, 0)) == 0)
+	{
+	  warning ("'%s': bad step-count; command ignored.", *line);
+	  return BADLINE;
+	}
+      return STEPPING;
+    }
+  else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
+    return END;
+  else
+    {
+      warning ("'%s' is not a supported tracepoint action.", *line);
+      return BADLINE;
+    }
+}
+
+/* worker function */
+void
+free_actions (struct tracepoint *t)
+{
+  struct action_line *line, *next;
+
+  for (line = t->actions; line; line = next)
+    {
+      next = line->next;
+      if (line->action)
+	xfree (line->action);
+      xfree (line);
+    }
+  t->actions = NULL;
+}
+
+static void
+do_free_actions_cleanup (void *t)
+{
+  free_actions (t);
+}
+
+static struct cleanup *
+make_cleanup_free_actions (struct tracepoint *t)
+{
+  return make_cleanup (do_free_actions_cleanup, t);
+}
+
+struct memrange
+{
+  int type;		/* 0 for absolute memory range, else basereg number */
+  bfd_signed_vma start;
+  bfd_signed_vma end;
+};
+
+struct collection_list
+  {
+    unsigned char regs_mask[8];	/* room for up to 256 regs */
+    long listsize;
+    long next_memrange;
+    struct memrange *list;
+    long aexpr_listsize;	/* size of array pointed to by expr_list elt */
+    long next_aexpr_elt;
+    struct agent_expr **aexpr_list;
+
+  }
+tracepoint_list, stepping_list;
+
+/* MEMRANGE functions: */
+
+static int memrange_cmp (const void *, const void *);
+
+/* compare memranges for qsort */
+static int
+memrange_cmp (const void *va, const void *vb)
+{
+  const struct memrange *a = va, *b = vb;
+
+  if (a->type < b->type)
+    return -1;
+  if (a->type > b->type)
+    return 1;
+  if (a->type == 0)
+    {
+      if ((bfd_vma) a->start < (bfd_vma) b->start)
+	return -1;
+      if ((bfd_vma) a->start > (bfd_vma) b->start)
+	return 1;
+    }
+  else
+    {
+      if (a->start < b->start)
+	return -1;
+      if (a->start > b->start)
+	return 1;
+    }
+  return 0;
+}
+
+/* Sort the memrange list using qsort, and merge adjacent memranges */
+static void
+memrange_sortmerge (struct collection_list *memranges)
+{
+  int a, b;
+
+  qsort (memranges->list, memranges->next_memrange,
+	 sizeof (struct memrange), memrange_cmp);
+  if (memranges->next_memrange > 0)
+    {
+      for (a = 0, b = 1; b < memranges->next_memrange; b++)
+	{
+	  if (memranges->list[a].type == memranges->list[b].type &&
+	      memranges->list[b].start - memranges->list[a].end <=
+	      MAX_REGISTER_VIRTUAL_SIZE)
+	    {
+	      /* memrange b starts before memrange a ends; merge them.  */
+	      if (memranges->list[b].end > memranges->list[a].end)
+		memranges->list[a].end = memranges->list[b].end;
+	      continue;		/* next b, same a */
+	    }
+	  a++;			/* next a */
+	  if (a != b)
+	    memcpy (&memranges->list[a], &memranges->list[b],
+		    sizeof (struct memrange));
+	}
+      memranges->next_memrange = a + 1;
+    }
+}
+
+/* Add a register to a collection list */
+static void
+add_register (struct collection_list *collection, unsigned int regno)
+{
+  if (info_verbose)
+    printf_filtered ("collect register %d\n", regno);
+  if (regno > (8 * sizeof (collection->regs_mask)))
+    error ("Internal: register number %d too large for tracepoint",
+	   regno);
+  collection->regs_mask[regno / 8] |= 1 << (regno % 8);
+}
+
+/* Add a memrange to a collection list */
+static void
+add_memrange (struct collection_list *memranges, int type, bfd_signed_vma base,
+	      unsigned long len)
+{
+  if (info_verbose)
+    {
+      printf_filtered ("(%d,", type);
+      printf_vma (base);
+      printf_filtered (",%ld)\n", len);
+    }
+
+  /* type: 0 == memory, n == basereg */
+  memranges->list[memranges->next_memrange].type = type;
+  /* base: addr if memory, offset if reg relative. */
+  memranges->list[memranges->next_memrange].start = base;
+  /* len: we actually save end (base + len) for convenience */
+  memranges->list[memranges->next_memrange].end = base + len;
+  memranges->next_memrange++;
+  if (memranges->next_memrange >= memranges->listsize)
+    {
+      memranges->listsize *= 2;
+      memranges->list = xrealloc (memranges->list,
+				  memranges->listsize);
+    }
+
+  if (type != -1)		/* better collect the base register! */
+    add_register (memranges, type);
+}
+
+/* Add a symbol to a collection list */
+static void
+collect_symbol (struct collection_list *collect, struct symbol *sym,
+		long frame_regno, long frame_offset)
+{
+  unsigned long len;
+  unsigned int reg;
+  bfd_signed_vma offset;
+
+  len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
+  switch (SYMBOL_CLASS (sym))
+    {
+    default:
+      printf_filtered ("%s: don't know symbol class %d\n",
+		       SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
+      break;
+    case LOC_CONST:
+      printf_filtered ("constant %s (value %ld) will not be collected.\n",
+		       SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
+      break;
+    case LOC_STATIC:
+      offset = SYMBOL_VALUE_ADDRESS (sym);
+      if (info_verbose)
+	{
+	  char tmp[40];
+
+	  sprintf_vma (tmp, offset);
+	  printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
+			   SYMBOL_NAME (sym), len, tmp /* address */);
+	}
+      add_memrange (collect, -1, offset, len);	/* 0 == memory */
+      break;
+    case LOC_REGISTER:
+    case LOC_REGPARM:
+      reg = SYMBOL_VALUE (sym);
+      if (info_verbose)
+	printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
+      add_register (collect, reg);
+      /* check for doubles stored in two registers */
+      /* FIXME: how about larger types stored in 3 or more regs? */
+      if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
+	  len > REGISTER_RAW_SIZE (reg))
+	add_register (collect, reg + 1);
+      break;
+    case LOC_REF_ARG:
+      printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
+      printf_filtered ("       (will not collect %s)\n",
+		       SYMBOL_NAME (sym));
+      break;
+    case LOC_ARG:
+      reg = frame_regno;
+      offset = frame_offset + SYMBOL_VALUE (sym);
+      if (info_verbose)
+	{
+	  printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
+			   SYMBOL_NAME (sym), len);
+	  printf_vma (offset);
+	  printf_filtered (" from frame ptr reg %d\n", reg);
+	}
+      add_memrange (collect, reg, offset, len);
+      break;
+    case LOC_REGPARM_ADDR:
+      reg = SYMBOL_VALUE (sym);
+      offset = 0;
+      if (info_verbose)
+	{
+	  printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
+			   SYMBOL_NAME (sym), len);
+	  printf_vma (offset);
+	  printf_filtered (" from reg %d\n", reg);
+	}
+      add_memrange (collect, reg, offset, len);
+      break;
+    case LOC_LOCAL:
+    case LOC_LOCAL_ARG:
+      reg = frame_regno;
+      offset = frame_offset + SYMBOL_VALUE (sym);
+      if (info_verbose)
+	{
+	  printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
+			   SYMBOL_NAME (sym), len);
+	  printf_vma (offset);
+	  printf_filtered (" from frame ptr reg %d\n", reg);
+	}
+      add_memrange (collect, reg, offset, len);
+      break;
+    case LOC_BASEREG:
+    case LOC_BASEREG_ARG:
+      reg = SYMBOL_BASEREG (sym);
+      offset = SYMBOL_VALUE (sym);
+      if (info_verbose)
+	{
+	  printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
+			   SYMBOL_NAME (sym), len);
+	  printf_vma (offset);
+	  printf_filtered (" from basereg %d\n", reg);
+	}
+      add_memrange (collect, reg, offset, len);
+      break;
+    case LOC_UNRESOLVED:
+      printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym));
+      break;
+    case LOC_OPTIMIZED_OUT:
+      printf_filtered ("%s has been optimized out of existence.\n",
+		       SYMBOL_NAME (sym));
+      break;
+    }
+}
+
+/* Add all locals (or args) symbols to collection list */
+static void
+add_local_symbols (struct collection_list *collect, CORE_ADDR pc,
+		   long frame_regno, long frame_offset, int type)
+{
+  struct symbol *sym;
+  struct block *block;
+  int i, count = 0;
+
+  block = block_for_pc (pc);
+  while (block != 0)
+    {
+      QUIT;			/* allow user to bail out with ^C */
+      ALL_BLOCK_SYMBOLS (block, i, sym)
+	{
+	  switch (SYMBOL_CLASS (sym))
+	    {
+	    default:
+	      warning ("don't know how to trace local symbol %s", 
+		       SYMBOL_NAME (sym));
+	    case LOC_LOCAL:
+	    case LOC_STATIC:
+	    case LOC_REGISTER:
+	    case LOC_BASEREG:
+	      if (type == 'L')	/* collecting Locals */
+		{
+		  count++;
+		  collect_symbol (collect, sym, frame_regno, frame_offset);
+		}
+	      break;
+	    case LOC_ARG:
+	    case LOC_LOCAL_ARG:
+	    case LOC_REF_ARG:
+	    case LOC_REGPARM:
+	    case LOC_REGPARM_ADDR:
+	    case LOC_BASEREG_ARG:
+	      if (type == 'A')	/* collecting Arguments */
+		{
+		  count++;
+		  collect_symbol (collect, sym, frame_regno, frame_offset);
+		}
+	    }
+	}
+      if (BLOCK_FUNCTION (block))
+	break;
+      else
+	block = BLOCK_SUPERBLOCK (block);
+    }
+  if (count == 0)
+    warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
+}
+
+/* worker function */
+static void
+clear_collection_list (struct collection_list *list)
+{
+  int ndx;
+
+  list->next_memrange = 0;
+  for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
+    {
+      free_agent_expr (list->aexpr_list[ndx]);
+      list->aexpr_list[ndx] = NULL;
+    }
+  list->next_aexpr_elt = 0;
+  memset (list->regs_mask, 0, sizeof (list->regs_mask));
+}
+
+/* reduce a collection list to string form (for gdb protocol) */
+static char **
+stringify_collection_list (struct collection_list *list, char *string)
+{
+  char temp_buf[2048];
+  char tmp2[40];
+  int count;
+  int ndx = 0;
+  char *(*str_list)[];
+  char *end;
+  long i;
+
+  count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
+  str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
+
+  for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
+    if (list->regs_mask[i] != 0)	/* skip leading zeroes in regs_mask */
+      break;
+  if (list->regs_mask[i] != 0)	/* prepare to send regs_mask to the stub */
+    {
+      if (info_verbose)
+	printf_filtered ("\nCollecting registers (mask): 0x");
+      end = temp_buf;
+      *end++ = 'R';
+      for (; i >= 0; i--)
+	{
+	  QUIT;			/* allow user to bail out with ^C */
+	  if (info_verbose)
+	    printf_filtered ("%02X", list->regs_mask[i]);
+	  sprintf (end, "%02X", list->regs_mask[i]);
+	  end += 2;
+	}
+      (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
+      ndx++;
+    }
+  if (info_verbose)
+    printf_filtered ("\n");
+  if (list->next_memrange > 0 && info_verbose)
+    printf_filtered ("Collecting memranges: \n");
+  for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
+    {
+      QUIT;			/* allow user to bail out with ^C */
+      sprintf_vma (tmp2, list->list[i].start);
+      if (info_verbose)
+	{
+	  printf_filtered ("(%d, %s, %ld)\n", 
+			   list->list[i].type, 
+			   tmp2, 
+			   (long) (list->list[i].end - list->list[i].start));
+	}
+      if (count + 27 > MAX_AGENT_EXPR_LEN)
+	{
+	  (*str_list)[ndx] = savestring (temp_buf, count);
+	  ndx++;
+	  count = 0;
+	  end = temp_buf;
+	}
+
+      sprintf (end, "M%X,%s,%lX", 
+	       list->list[i].type,
+	       tmp2,
+	       (long) (list->list[i].end - list->list[i].start));
+
+      count += strlen (end);
+      end += count;
+    }
+
+  for (i = 0; i < list->next_aexpr_elt; i++)
+    {
+      QUIT;			/* allow user to bail out with ^C */
+      if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
+	{
+	  (*str_list)[ndx] = savestring (temp_buf, count);
+	  ndx++;
+	  count = 0;
+	  end = temp_buf;
+	}
+      sprintf (end, "X%08X,", list->aexpr_list[i]->len);
+      end += 10;		/* 'X' + 8 hex digits + ',' */
+      count += 10;
+
+      end = mem2hex (list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
+      count += 2 * list->aexpr_list[i]->len;
+    }
+
+  if (count != 0)
+    {
+      (*str_list)[ndx] = savestring (temp_buf, count);
+      ndx++;
+      count = 0;
+      end = temp_buf;
+    }
+  (*str_list)[ndx] = NULL;
+
+  if (ndx == 0)
+    return NULL;
+  else
+    return *str_list;
+}
+
+static void
+free_actions_list_cleanup_wrapper (void *al)
+{
+  free_actions_list (al);
+}
+
+static void
+free_actions_list (char **actions_list)
+{
+  int ndx;
+
+  if (actions_list == 0)
+    return;
+
+  for (ndx = 0; actions_list[ndx]; ndx++)
+    xfree (actions_list[ndx]);
+
+  xfree (actions_list);
+}
+
+/* render all actions into gdb protocol */
+static void
+encode_actions (struct tracepoint *t, char ***tdp_actions,
+		char ***stepping_actions)
+{
+  static char tdp_buff[2048], step_buff[2048];
+  char *action_exp;
+  struct expression *exp = NULL;
+  struct action_line *action;
+  int i;
+  struct value *tempval;
+  struct collection_list *collect;
+  struct cmd_list_element *cmd;
+  struct agent_expr *aexpr;
+  int frame_reg;
+  LONGEST frame_offset;
+
+
+  clear_collection_list (&tracepoint_list);
+  clear_collection_list (&stepping_list);
+  collect = &tracepoint_list;
+
+  *tdp_actions = NULL;
+  *stepping_actions = NULL;
+
+  TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
+
+  for (action = t->actions; action; action = action->next)
+    {
+      QUIT;			/* allow user to bail out with ^C */
+      action_exp = action->action;
+      while (isspace ((int) *action_exp))
+	action_exp++;
+
+      if (*action_exp == '#')	/* comment line */
+	return;
+
+      cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
+      if (cmd == 0)
+	error ("Bad action list item: %s", action_exp);
+
+      if (cmd_cfunc_eq (cmd, collect_pseudocommand))
+	{
+	  do
+	    {			/* repeat over a comma-separated list */
+	      QUIT;		/* allow user to bail out with ^C */
+	      while (isspace ((int) *action_exp))
+		action_exp++;
+
+	      if (0 == strncasecmp ("$reg", action_exp, 4))
+		{
+		  for (i = 0; i < NUM_REGS; i++)
+		    add_register (collect, i);
+		  action_exp = strchr (action_exp, ',');	/* more? */
+		}
+	      else if (0 == strncasecmp ("$arg", action_exp, 4))
+		{
+		  add_local_symbols (collect,
+				     t->address,
+				     frame_reg,
+				     frame_offset,
+				     'A');
+		  action_exp = strchr (action_exp, ',');	/* more? */
+		}
+	      else if (0 == strncasecmp ("$loc", action_exp, 4))
+		{
+		  add_local_symbols (collect,
+				     t->address,
+				     frame_reg,
+				     frame_offset,
+				     'L');
+		  action_exp = strchr (action_exp, ',');	/* more? */
+		}
+	      else
+		{
+		  unsigned long addr, len;
+		  struct cleanup *old_chain = NULL;
+		  struct cleanup *old_chain1 = NULL;
+		  struct agent_reqs areqs;
+
+		  exp = parse_exp_1 (&action_exp, 
+				     block_for_pc (t->address), 1);
+		  old_chain = make_cleanup (free_current_contents, &exp);
+
+		  switch (exp->elts[0].opcode)
+		    {
+		    case OP_REGISTER:
+		      i = exp->elts[1].longconst;
+		      if (info_verbose)
+			printf_filtered ("OP_REGISTER: ");
+		      add_register (collect, i);
+		      break;
+
+		    case UNOP_MEMVAL:
+		      /* safe because we know it's a simple expression */
+		      tempval = evaluate_expression (exp);
+		      addr = VALUE_ADDRESS (tempval) + VALUE_OFFSET (tempval);
+		      len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
+		      add_memrange (collect, -1, addr, len);
+		      break;
+
+		    case OP_VAR_VALUE:
+		      collect_symbol (collect,
+				      exp->elts[2].symbol,
+				      frame_reg,
+				      frame_offset);
+		      break;
+
+		    default:	/* full-fledged expression */
+		      aexpr = gen_trace_for_expr (t->address, exp);
+
+		      old_chain1 = make_cleanup_free_agent_expr (aexpr);
+
+		      ax_reqs (aexpr, &areqs);
+		      if (areqs.flaw != agent_flaw_none)
+			error ("malformed expression");
+
+		      if (areqs.min_height < 0)
+			error ("gdb: Internal error: expression has min height < 0");
+		      if (areqs.max_height > 20)
+			error ("expression too complicated, try simplifying");
+
+		      discard_cleanups (old_chain1);
+		      add_aexpr (collect, aexpr);
+
+		      /* take care of the registers */
+		      if (areqs.reg_mask_len > 0)
+			{
+			  int ndx1;
+			  int ndx2;
+
+			  for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
+			    {
+			      QUIT;	/* allow user to bail out with ^C */
+			      if (areqs.reg_mask[ndx1] != 0)
+				{
+				  /* assume chars have 8 bits */
+				  for (ndx2 = 0; ndx2 < 8; ndx2++)
+				    if (areqs.reg_mask[ndx1] & (1 << ndx2))
+				      /* it's used -- record it */
+				      add_register (collect, ndx1 * 8 + ndx2);
+				}
+			    }
+			}
+		      break;
+		    }		/* switch */
+		  do_cleanups (old_chain);
+		}		/* do */
+	    }
+	  while (action_exp && *action_exp++ == ',');
+	}			/* if */
+      else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
+	{
+	  collect = &stepping_list;
+	}
+      else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
+	{
+	  if (collect == &stepping_list)	/* end stepping actions */
+	    collect = &tracepoint_list;
+	  else
+	    break;		/* end tracepoint actions */
+	}
+    }				/* for */
+  memrange_sortmerge (&tracepoint_list);
+  memrange_sortmerge (&stepping_list);
+
+  *tdp_actions = stringify_collection_list (&tracepoint_list, tdp_buff);
+  *stepping_actions = stringify_collection_list (&stepping_list, step_buff);
+}
+
+static void
+add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
+{
+  if (collect->next_aexpr_elt >= collect->aexpr_listsize)
+    {
+      collect->aexpr_list =
+	xrealloc (collect->aexpr_list,
+		2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
+      collect->aexpr_listsize *= 2;
+    }
+  collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
+  collect->next_aexpr_elt++;
+}
+
+static char target_buf[2048];
+
+/* Set "transparent" memory ranges
+
+   Allow trace mechanism to treat text-like sections
+   (and perhaps all read-only sections) transparently, 
+   i.e. don't reject memory requests from these address ranges
+   just because they haven't been collected.  */
+
+static void
+remote_set_transparent_ranges (void)
+{
+  extern bfd *exec_bfd;
+  asection *s;
+  bfd_size_type size;
+  bfd_vma lma;
+  int anysecs = 0;
+
+  if (!exec_bfd)
+    return;			/* no information to give. */
+
+  strcpy (target_buf, "QTro");
+  for (s = exec_bfd->sections; s; s = s->next)
+    {
+      char tmp1[40], tmp2[40];
+
+      if ((s->flags & SEC_LOAD) == 0 ||
+      /* (s->flags & SEC_CODE)     == 0 || */
+	  (s->flags & SEC_READONLY) == 0)
+	continue;
+
+      anysecs = 1;
+      lma = s->lma;
+      size = bfd_get_section_size_before_reloc (s);
+      sprintf_vma (tmp1, lma);
+      sprintf_vma (tmp2, lma + size);
+      sprintf (target_buf + strlen (target_buf), 
+	       ":%s,%s", tmp1, tmp2);
+    }
+  if (anysecs)
+    {
+      putpkt (target_buf);
+      getpkt (target_buf, sizeof (target_buf), 0);
+    }
+}
+
+/* tstart command:
+
+   Tell target to clear any previous trace experiment.
+   Walk the list of tracepoints, and send them (and their actions)
+   to the target.  If no errors, 
+   Tell target to start a new trace experiment.  */
+
+static void
+trace_start_command (char *args, int from_tty)
+{				/* STUB_COMM MOSTLY_IMPLEMENTED */
+  struct tracepoint *t;
+  char buf[2048];
+  char **tdp_actions;
+  char **stepping_actions;
+  int ndx;
+  struct cleanup *old_chain = NULL;
+
+  dont_repeat ();		/* like "run", dangerous to repeat accidentally */
+
+  if (target_is_remote ())
+    {
+      putpkt ("QTinit");
+      remote_get_noisy_reply (target_buf, sizeof (target_buf));
+      if (strcmp (target_buf, "OK"))
+	error ("Target does not support this command.");
+
+      ALL_TRACEPOINTS (t)
+      {
+	char tmp[40];
+
+	sprintf_vma (tmp, t->address);
+	sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, tmp, /* address */
+		 t->enabled_p ? 'E' : 'D',
+		 t->step_count, t->pass_count);
+
+	if (t->actions)
+	  strcat (buf, "-");
+	putpkt (buf);
+	remote_get_noisy_reply (target_buf, sizeof (target_buf));
+	if (strcmp (target_buf, "OK"))
+	  error ("Target does not support tracepoints.");
+
+	if (t->actions)
+	  {
+	    encode_actions (t, &tdp_actions, &stepping_actions);
+	    old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
+				      tdp_actions);
+	    (void) make_cleanup (free_actions_list_cleanup_wrapper,
+				 stepping_actions);
+
+	    /* do_single_steps (t); */
+	    if (tdp_actions)
+	      {
+		for (ndx = 0; tdp_actions[ndx]; ndx++)
+		  {
+		    QUIT;	/* allow user to bail out with ^C */
+		    sprintf (buf, "QTDP:-%x:%s:%s%c",
+			     t->number, tmp, /* address */
+			     tdp_actions[ndx],
+			     ((tdp_actions[ndx + 1] || stepping_actions)
+			      ? '-' : 0));
+		    putpkt (buf);
+		    remote_get_noisy_reply (target_buf, sizeof (target_buf));
+		    if (strcmp (target_buf, "OK"))
+		      error ("Error on target while setting tracepoints.");
+		  }
+	      }
+	    if (stepping_actions)
+	      {
+		for (ndx = 0; stepping_actions[ndx]; ndx++)
+		  {
+		    QUIT;	/* allow user to bail out with ^C */
+		    sprintf (buf, "QTDP:-%x:%s:%s%s%s",
+			     t->number, tmp, /* address */
+			     ((ndx == 0) ? "S" : ""),
+			     stepping_actions[ndx],
+			     (stepping_actions[ndx + 1] ? "-" : ""));
+		    putpkt (buf);
+		    remote_get_noisy_reply (target_buf, sizeof (target_buf));
+		    if (strcmp (target_buf, "OK"))
+		      error ("Error on target while setting tracepoints.");
+		  }
+	      }
+
+	    do_cleanups (old_chain);
+	  }
+      }
+      /* Tell target to treat text-like sections as transparent */
+      remote_set_transparent_ranges ();
+      /* Now insert traps and begin collecting data */
+      putpkt ("QTStart");
+      remote_get_noisy_reply (target_buf, sizeof (target_buf));
+      if (strcmp (target_buf, "OK"))
+	error ("Bogus reply from target: %s", target_buf);
+      set_traceframe_num (-1);	/* all old traceframes invalidated */
+      set_tracepoint_num (-1);
+      set_traceframe_context (-1);
+      trace_running_p = 1;
+      if (trace_start_stop_hook)
+	trace_start_stop_hook (1, from_tty);
+
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+/* tstop command */
+static void
+trace_stop_command (char *args, int from_tty)
+{				/* STUB_COMM IS_IMPLEMENTED */
+  if (target_is_remote ())
+    {
+      putpkt ("QTStop");
+      remote_get_noisy_reply (target_buf, sizeof (target_buf));
+      if (strcmp (target_buf, "OK"))
+	error ("Bogus reply from target: %s", target_buf);
+      trace_running_p = 0;
+      if (trace_start_stop_hook)
+	trace_start_stop_hook (0, from_tty);
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+unsigned long trace_running_p;
+
+/* tstatus command */
+static void
+trace_status_command (char *args, int from_tty)
+{				/* STUB_COMM IS_IMPLEMENTED */
+  if (target_is_remote ())
+    {
+      putpkt ("qTStatus");
+      remote_get_noisy_reply (target_buf, sizeof (target_buf));
+
+      if (target_buf[0] != 'T' ||
+	  (target_buf[1] != '0' && target_buf[1] != '1'))
+	error ("Bogus reply from target: %s", target_buf);
+
+      /* exported for use by the GUI */
+      trace_running_p = (target_buf[1] == '1');
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+/* Worker function for the various flavors of the tfind command */
+static void
+finish_tfind_command (char *msg,
+		      long sizeof_msg,
+		      int from_tty)
+{
+  int target_frameno = -1, target_tracept = -1;
+  CORE_ADDR old_frame_addr;
+  struct symbol *old_func;
+  char *reply;
+
+  old_frame_addr = FRAME_FP (get_current_frame ());
+  old_func = find_pc_function (read_pc ());
+
+  putpkt (msg);
+  reply = remote_get_noisy_reply (msg, sizeof_msg);
+
+  while (reply && *reply)
+    switch (*reply)
+      {
+      case 'F':
+	if ((target_frameno = (int) strtol (++reply, &reply, 16)) == -1)
+	  {
+	    /* A request for a non-existant trace frame has failed.
+	       Our response will be different, depending on FROM_TTY:
+
+	       If FROM_TTY is true, meaning that this command was 
+	       typed interactively by the user, then give an error
+	       and DO NOT change the state of traceframe_number etc.
+
+	       However if FROM_TTY is false, meaning that we're either
+	       in a script, a loop, or a user-defined command, then 
+	       DON'T give an error, but DO change the state of
+	       traceframe_number etc. to invalid.
+
+	       The rationalle is that if you typed the command, you
+	       might just have committed a typo or something, and you'd
+	       like to NOT lose your current debugging state.  However
+	       if you're in a user-defined command or especially in a
+	       loop, then you need a way to detect that the command
+	       failed WITHOUT aborting.  This allows you to write
+	       scripts that search thru the trace buffer until the end,
+	       and then continue on to do something else.  */
+
+	    if (from_tty)
+	      error ("Target failed to find requested trace frame.");
+	    else
+	      {
+		if (info_verbose)
+		  printf_filtered ("End of trace buffer.\n");
+		/* The following will not recurse, since it's special-cased */
+		trace_find_command ("-1", from_tty);
+		reply = NULL;	/* break out of loop, 
+				   (avoid recursive nonsense) */
+	      }
+	  }
+	break;
+      case 'T':
+	if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
+	  error ("Target failed to find requested trace frame.");
+	break;
+      case 'O':		/* "OK"? */
+	if (reply[1] == 'K' && reply[2] == '\0')
+	  reply += 2;
+	else
+	  error ("Bogus reply from target: %s", reply);
+	break;
+      default:
+	error ("Bogus reply from target: %s", reply);
+      }
+
+  flush_cached_frames ();
+  registers_changed ();
+  select_frame (get_current_frame ());
+  set_traceframe_num (target_frameno);
+  set_tracepoint_num (target_tracept);
+  if (target_frameno == -1)
+    set_traceframe_context (-1);
+  else
+    set_traceframe_context (read_pc ());
+
+  if (from_tty)
+    {
+      int source_only;
+
+      /* NOTE: in immitation of the step command, try to determine
+         whether we have made a transition from one function to another.
+         If so, we'll print the "stack frame" (ie. the new function and
+         it's arguments) -- otherwise we'll just show the new source line.
+
+         This determination is made by checking (1) whether the current
+         function has changed, and (2) whether the current FP has changed.
+         Hack: if the FP wasn't collected, either at the current or the
+         previous frame, assume that the FP has NOT changed.  */
+
+      if (old_func == find_pc_function (read_pc ()) &&
+	  (old_frame_addr == 0 ||
+	   FRAME_FP (get_current_frame ()) == 0 ||
+	   old_frame_addr == FRAME_FP (get_current_frame ())))
+	source_only = -1;
+      else
+	source_only = 1;
+
+      print_stack_frame (selected_frame, frame_relative_level (selected_frame),
+			 source_only);
+      do_displays ();
+    }
+}
+
+/* trace_find_command takes a trace frame number n, 
+   sends "QTFrame:<n>" to the target, 
+   and accepts a reply that may contain several optional pieces
+   of information: a frame number, a tracepoint number, and an
+   indication of whether this is a trap frame or a stepping frame.
+
+   The minimal response is just "OK" (which indicates that the 
+   target does not give us a frame number or a tracepoint number).
+   Instead of that, the target may send us a string containing
+   any combination of:
+   F<hexnum>    (gives the selected frame number)
+   T<hexnum>    (gives the selected tracepoint number)
+ */
+
+/* tfind command */
+static void
+trace_find_command (char *args, int from_tty)
+{				/* STUB_COMM PART_IMPLEMENTED */
+  /* this should only be called with a numeric argument */
+  int frameno = -1;
+
+  if (target_is_remote ())
+    {
+      if (trace_find_hook)
+	trace_find_hook (args, from_tty);
+
+      if (args == 0 || *args == 0)
+	{			/* TFIND with no args means find NEXT trace frame. */
+	  if (traceframe_number == -1)
+	    frameno = 0;	/* "next" is first one */
+	  else
+	    frameno = traceframe_number + 1;
+	}
+      else if (0 == strcmp (args, "-"))
+	{
+	  if (traceframe_number == -1)
+	    error ("not debugging trace buffer");
+	  else if (from_tty && traceframe_number == 0)
+	    error ("already at start of trace buffer");
+
+	  frameno = traceframe_number - 1;
+	}
+      else
+	frameno = parse_and_eval_long (args);
+
+      if (frameno < -1)
+	error ("invalid input (%d is less than zero)", frameno);
+
+      sprintf (target_buf, "QTFrame:%x", frameno);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+/* tfind end */
+static void
+trace_find_end_command (char *args, int from_tty)
+{
+  trace_find_command ("-1", from_tty);
+}
+
+/* tfind none */
+static void
+trace_find_none_command (char *args, int from_tty)
+{
+  trace_find_command ("-1", from_tty);
+}
+
+/* tfind start */
+static void
+trace_find_start_command (char *args, int from_tty)
+{
+  trace_find_command ("0", from_tty);
+}
+
+/* tfind pc command */
+static void
+trace_find_pc_command (char *args, int from_tty)
+{				/* STUB_COMM PART_IMPLEMENTED */
+  CORE_ADDR pc;
+  char tmp[40];
+
+  if (target_is_remote ())
+    {
+      if (args == 0 || *args == 0)
+	pc = read_pc ();	/* default is current pc */
+      else
+	pc = parse_and_eval_address (args);
+
+      sprintf_vma (tmp, pc);
+      sprintf (target_buf, "QTFrame:pc:%s", tmp);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+/* tfind tracepoint command */
+static void
+trace_find_tracepoint_command (char *args, int from_tty)
+{				/* STUB_COMM PART_IMPLEMENTED */
+  int tdp;
+
+  if (target_is_remote ())
+    {
+      if (args == 0 || *args == 0)
+	{
+	  if (tracepoint_number == -1)
+	    error ("No current tracepoint -- please supply an argument.");
+	  else
+	    tdp = tracepoint_number;	/* default is current TDP */
+	}
+      else
+	tdp = parse_and_eval_long (args);
+
+      sprintf (target_buf, "QTFrame:tdp:%x", tdp);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+/* TFIND LINE command:
+
+   This command will take a sourceline for argument, just like BREAK
+   or TRACE (ie. anything that "decode_line_1" can handle).  
+
+   With no argument, this command will find the next trace frame 
+   corresponding to a source line OTHER THAN THE CURRENT ONE.  */
+
+static void
+trace_find_line_command (char *args, int from_tty)
+{				/* STUB_COMM PART_IMPLEMENTED */
+  static CORE_ADDR start_pc, end_pc;
+  struct symtabs_and_lines sals;
+  struct symtab_and_line sal;
+  struct cleanup *old_chain;
+  char   startpc_str[40], endpc_str[40];
+
+  if (target_is_remote ())
+    {
+      if (args == 0 || *args == 0)
+	{
+	  sal = find_pc_line ((get_current_frame ())->pc, 0);
+	  sals.nelts = 1;
+	  sals.sals = (struct symtab_and_line *)
+	    xmalloc (sizeof (struct symtab_and_line));
+	  sals.sals[0] = sal;
+	}
+      else
+	{
+	  sals = decode_line_spec (args, 1);
+	  sal = sals.sals[0];
+	}
+
+      old_chain = make_cleanup (xfree, sals.sals);
+      if (sal.symtab == 0)
+	{
+	  printf_filtered ("TFIND: No line number information available");
+	  if (sal.pc != 0)
+	    {
+	      /* This is useful for "info line *0x7f34".  If we can't tell the
+	         user about a source line, at least let them have the symbolic
+	         address.  */
+	      printf_filtered (" for address ");
+	      wrap_here ("  ");
+	      print_address (sal.pc, gdb_stdout);
+	      printf_filtered (";\n -- will attempt to find by PC. \n");
+	    }
+	  else
+	    {
+	      printf_filtered (".\n");
+	      return;		/* no line, no PC; what can we do? */
+	    }
+	}
+      else if (sal.line > 0
+	       && find_line_pc_range (sal, &start_pc, &end_pc))
+	{
+	  if (start_pc == end_pc)
+	    {
+	      printf_filtered ("Line %d of \"%s\"",
+			       sal.line, sal.symtab->filename);
+	      wrap_here ("  ");
+	      printf_filtered (" is at address ");
+	      print_address (start_pc, gdb_stdout);
+	      wrap_here ("  ");
+	      printf_filtered (" but contains no code.\n");
+	      sal = find_pc_line (start_pc, 0);
+	      if (sal.line > 0 &&
+		  find_line_pc_range (sal, &start_pc, &end_pc) &&
+		  start_pc != end_pc)
+		printf_filtered ("Attempting to find line %d instead.\n",
+				 sal.line);
+	      else
+		error ("Cannot find a good line.");
+	    }
+	}
+      else
+	/* Is there any case in which we get here, and have an address
+	   which the user would want to see?  If we have debugging symbols
+	   and no line numbers?  */
+	error ("Line number %d is out of range for \"%s\".\n",
+	       sal.line, sal.symtab->filename);
+
+      sprintf_vma (startpc_str, start_pc);
+      sprintf_vma (endpc_str, end_pc - 1);
+      if (args && *args)	/* find within range of stated line */
+	sprintf (target_buf, "QTFrame:range:%s:%s", startpc_str, endpc_str);
+      else			/* find OUTSIDE OF range of CURRENT line */
+	sprintf (target_buf, "QTFrame:outside:%s:%s", startpc_str, endpc_str);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+      do_cleanups (old_chain);
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+/* tfind range command */
+static void
+trace_find_range_command (char *args, int from_tty)
+{
+  static CORE_ADDR start, stop;
+  char start_str[40], stop_str[40];
+  char *tmp;
+
+  if (target_is_remote ())
+    {
+      if (args == 0 || *args == 0)
+	{		/* XXX FIXME: what should default behavior be? */
+	  printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
+	  return;
+	}
+
+      if (0 != (tmp = strchr (args, ',')))
+	{
+	  *tmp++ = '\0';	/* terminate start address */
+	  while (isspace ((int) *tmp))
+	    tmp++;
+	  start = parse_and_eval_address (args);
+	  stop = parse_and_eval_address (tmp);
+	}
+      else
+	{			/* no explicit end address? */
+	  start = parse_and_eval_address (args);
+	  stop = start + 1;	/* ??? */
+	}
+
+      sprintf_vma (start_str, start);
+      sprintf_vma (stop_str, stop);
+      sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+/* tfind outside command */
+static void
+trace_find_outside_command (char *args, int from_tty)
+{
+  CORE_ADDR start, stop;
+  char start_str[40], stop_str[40];
+  char *tmp;
+
+  if (target_is_remote ())
+    {
+      if (args == 0 || *args == 0)
+	{		/* XXX FIXME: what should default behavior be? */
+	  printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
+	  return;
+	}
+
+      if (0 != (tmp = strchr (args, ',')))
+	{
+	  *tmp++ = '\0';	/* terminate start address */
+	  while (isspace ((int) *tmp))
+	    tmp++;
+	  start = parse_and_eval_address (args);
+	  stop = parse_and_eval_address (tmp);
+	}
+      else
+	{			/* no explicit end address? */
+	  start = parse_and_eval_address (args);
+	  stop = start + 1;	/* ??? */
+	}
+
+      sprintf_vma (start_str, start);
+      sprintf_vma (stop_str, stop);
+      sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str);
+      finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
+    }
+  else
+    error ("Trace can only be run on remote targets.");
+}
+
+/* save-tracepoints command */
+static void
+tracepoint_save_command (char *args, int from_tty)
+{
+  struct tracepoint *tp;
+  struct action_line *line;
+  FILE *fp;
+  char *i1 = "    ", *i2 = "      ";
+  char *indent, *actionline, *pathname;
+  char tmp[40];
+
+  if (args == 0 || *args == 0)
+    error ("Argument required (file name in which to save tracepoints");
+
+  if (tracepoint_chain == 0)
+    {
+      warning ("save-tracepoints: no tracepoints to save.\n");
+      return;
+    }
+
+  pathname = tilde_expand (args);
+  if (!(fp = fopen (pathname, "w")))
+    error ("Unable to open file '%s' for saving tracepoints (%s)",
+	   args, safe_strerror (errno));
+  xfree (pathname);
+  
+  ALL_TRACEPOINTS (tp)
+  {
+    if (tp->addr_string)
+      fprintf (fp, "trace %s\n", tp->addr_string);
+    else
+      {
+	sprintf_vma (tmp, tp->address);
+	fprintf (fp, "trace *0x%s\n", tmp);
+      }
+
+    if (tp->pass_count)
+      fprintf (fp, "  passcount %d\n", tp->pass_count);
+
+    if (tp->actions)
+      {
+	fprintf (fp, "  actions\n");
+	indent = i1;
+	for (line = tp->actions; line; line = line->next)
+	  {
+	    struct cmd_list_element *cmd;
+
+	    QUIT;		/* allow user to bail out with ^C */
+	    actionline = line->action;
+	    while (isspace ((int) *actionline))
+	      actionline++;
+
+	    fprintf (fp, "%s%s\n", indent, actionline);
+	    if (*actionline != '#')	/* skip for comment lines */
+	      {
+		cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
+		if (cmd == 0)
+		  error ("Bad action list item: %s", actionline);
+		if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
+		  indent = i2;
+		else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
+		  indent = i1;
+	      }
+	  }
+      }
+  }
+  fclose (fp);
+  if (from_tty)
+    printf_filtered ("Tracepoints saved to file '%s'.\n", args);
+  return;
+}
+
+/* info scope command: list the locals for a scope.  */
+static void
+scope_info (char *args, int from_tty)
+{
+  struct symtabs_and_lines sals;
+  struct symbol *sym;
+  struct minimal_symbol *msym;
+  struct block *block;
+  char **canonical, *symname, *save_args = args;
+  int i, j, count = 0;
+
+  if (args == 0 || *args == 0)
+    error ("requires an argument (function, line or *addr) to define a scope");
+
+  sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
+  if (sals.nelts == 0)
+    return;			/* presumably decode_line_1 has already warned */
+
+  /* Resolve line numbers to PC */
+  resolve_sal_pc (&sals.sals[0]);
+  block = block_for_pc (sals.sals[0].pc);
+
+  while (block != 0)
+    {
+      QUIT;			/* allow user to bail out with ^C */
+      ALL_BLOCK_SYMBOLS (block, i, sym)
+	{
+	  QUIT;			/* allow user to bail out with ^C */
+	  if (count == 0)
+	    printf_filtered ("Scope for %s:\n", save_args);
+	  count++;
+
+	  symname = SYMBOL_NAME (sym);
+	  if (symname == NULL || *symname == '\0')
+	    continue;		/* probably botched, certainly useless */
+
+	  printf_filtered ("Symbol %s is ", symname);
+	  switch (SYMBOL_CLASS (sym))
+	    {
+	    default:
+	    case LOC_UNDEF:	/* messed up symbol? */
+	      printf_filtered ("a bogus symbol, class %d.\n",
+			       SYMBOL_CLASS (sym));
+	      count--;		/* don't count this one */
+	      continue;
+	    case LOC_CONST:
+	      printf_filtered ("a constant with value %ld (0x%lx)",
+			       SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
+	      break;
+	    case LOC_CONST_BYTES:
+	      printf_filtered ("constant bytes: ");
+	      if (SYMBOL_TYPE (sym))
+		for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
+		  fprintf_filtered (gdb_stdout, " %02x",
+				    (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
+	      break;
+	    case LOC_STATIC:
+	      printf_filtered ("in static storage at address ");
+	      print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+	      break;
+	    case LOC_REGISTER:
+	      printf_filtered ("a local variable in register $%s",
+			       REGISTER_NAME (SYMBOL_VALUE (sym)));
+	      break;
+	    case LOC_ARG:
+	    case LOC_LOCAL_ARG:
+	      printf_filtered ("an argument at stack/frame offset %ld",
+			       SYMBOL_VALUE (sym));
+	      break;
+	    case LOC_LOCAL:
+	      printf_filtered ("a local variable at frame offset %ld",
+			       SYMBOL_VALUE (sym));
+	      break;
+	    case LOC_REF_ARG:
+	      printf_filtered ("a reference argument at offset %ld",
+			       SYMBOL_VALUE (sym));
+	      break;
+	    case LOC_REGPARM:
+	      printf_filtered ("an argument in register $%s",
+			       REGISTER_NAME (SYMBOL_VALUE (sym)));
+	      break;
+	    case LOC_REGPARM_ADDR:
+	      printf_filtered ("the address of an argument, in register $%s",
+			       REGISTER_NAME (SYMBOL_VALUE (sym)));
+	      break;
+	    case LOC_TYPEDEF:
+	      printf_filtered ("a typedef.\n");
+	      continue;
+	    case LOC_LABEL:
+	      printf_filtered ("a label at address ");
+	      print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
+	      break;
+	    case LOC_BLOCK:
+	      printf_filtered ("a function at address ");
+	      print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
+				     gdb_stdout);
+	      break;
+	    case LOC_BASEREG:
+	      printf_filtered ("a variable at offset %ld from register $%s",
+			       SYMBOL_VALUE (sym),
+			       REGISTER_NAME (SYMBOL_BASEREG (sym)));
+	      break;
+	    case LOC_BASEREG_ARG:
+	      printf_filtered ("an argument at offset %ld from register $%s",
+			       SYMBOL_VALUE (sym),
+			       REGISTER_NAME (SYMBOL_BASEREG (sym)));
+	      break;
+	    case LOC_UNRESOLVED:
+	      msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
+	      if (msym == NULL)
+		printf_filtered ("Unresolved Static");
+	      else
+		{
+		  printf_filtered ("static storage at address ");
+		  print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
+					 gdb_stdout);
+		}
+	      break;
+	    case LOC_OPTIMIZED_OUT:
+	      printf_filtered ("optimized out.\n");
+	      continue;
+	    }
+	  if (SYMBOL_TYPE (sym))
+	    printf_filtered (", length %d.\n",
+			   TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
+	}
+      if (BLOCK_FUNCTION (block))
+	break;
+      else
+	block = BLOCK_SUPERBLOCK (block);
+    }
+  if (count <= 0)
+    printf_filtered ("Scope for %s contains no locals or arguments.\n",
+		     save_args);
+}
+
+/* worker function (cleanup) */
+static void
+replace_comma (void *data)
+{
+  char *comma = data;
+  *comma = ',';
+}
+
+/* tdump command */
+static void
+trace_dump_command (char *args, int from_tty)
+{
+  struct tracepoint *t;
+  struct action_line *action;
+  char *action_exp, *next_comma;
+  struct cleanup *old_cleanups;
+  int stepping_actions = 0;
+  int stepping_frame = 0;
+
+  if (!target_is_remote ())
+    {
+      error ("Trace can only be run on remote targets.");
+      return;
+    }
+
+  if (tracepoint_number == -1)
+    {
+      warning ("No current trace frame.");
+      return;
+    }
+
+  ALL_TRACEPOINTS (t)
+    if (t->number == tracepoint_number)
+    break;
+
+  if (t == NULL)
+    error ("No known tracepoint matches 'current' tracepoint #%d.",
+	   tracepoint_number);
+
+  old_cleanups = make_cleanup (null_cleanup, NULL);
+
+  printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
+		   tracepoint_number, traceframe_number);
+
+  /* The current frame is a trap frame if the frame PC is equal
+     to the tracepoint PC.  If not, then the current frame was
+     collected during single-stepping.  */
+
+  stepping_frame = (t->address != read_pc ());
+
+  for (action = t->actions; action; action = action->next)
+    {
+      struct cmd_list_element *cmd;
+
+      QUIT;			/* allow user to bail out with ^C */
+      action_exp = action->action;
+      while (isspace ((int) *action_exp))
+	action_exp++;
+
+      /* The collection actions to be done while stepping are
+         bracketed by the commands "while-stepping" and "end".  */
+
+      if (*action_exp == '#')	/* comment line */
+	continue;
+
+      cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
+      if (cmd == 0)
+	error ("Bad action list item: %s", action_exp);
+
+      if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
+	stepping_actions = 1;
+      else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
+	stepping_actions = 0;
+      else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
+	{
+	  /* Display the collected data.
+	     For the trap frame, display only what was collected at the trap.
+	     Likewise for stepping frames, display only what was collected
+	     while stepping.  This means that the two boolean variables,
+	     STEPPING_FRAME and STEPPING_ACTIONS should be equal.  */
+	  if (stepping_frame == stepping_actions)
+	    {
+	      do
+		{		/* repeat over a comma-separated list */
+		  QUIT;		/* allow user to bail out with ^C */
+		  if (*action_exp == ',')
+		    action_exp++;
+		  while (isspace ((int) *action_exp))
+		    action_exp++;
+
+		  next_comma = strchr (action_exp, ',');
+
+		  if (0 == strncasecmp (action_exp, "$reg", 4))
+		    registers_info (NULL, from_tty);
+		  else if (0 == strncasecmp (action_exp, "$loc", 4))
+		    locals_info (NULL, from_tty);
+		  else if (0 == strncasecmp (action_exp, "$arg", 4))
+		    args_info (NULL, from_tty);
+		  else
+		    {		/* variable */
+		      if (next_comma)
+			{
+			  make_cleanup (replace_comma, next_comma);
+			  *next_comma = '\0';
+			}
+		      printf_filtered ("%s = ", action_exp);
+		      output_command (action_exp, from_tty);
+		      printf_filtered ("\n");
+		    }
+		  if (next_comma)
+		    *next_comma = ',';
+		  action_exp = next_comma;
+		}
+	      while (action_exp && *action_exp == ',');
+	    }
+	}
+    }
+  discard_cleanups (old_cleanups);
+}
+
+/* Convert the memory pointed to by mem into hex, placing result in buf.
+ * Return a pointer to the last char put in buf (null)
+ * "stolen" from sparc-stub.c
+ */
+
+static const char hexchars[] = "0123456789abcdef";
+
+static unsigned char *
+mem2hex (unsigned char *mem, unsigned char *buf, int count)
+{
+  unsigned char ch;
+
+  while (count-- > 0)
+    {
+      ch = *mem++;
+
+      *buf++ = hexchars[ch >> 4];
+      *buf++ = hexchars[ch & 0xf];
+    }
+
+  *buf = 0;
+
+  return buf;
+}
+
+int
+get_traceframe_number (void)
+{
+  return traceframe_number;
+}
+
+
+/* module initialization */
+void
+_initialize_tracepoint (void)
+{
+  struct cmd_list_element *c;
+
+  tracepoint_chain = 0;
+  tracepoint_count = 0;
+  traceframe_number = -1;
+  tracepoint_number = -1;
+
+  set_internalvar (lookup_internalvar ("tpnum"),
+		   value_from_longest (builtin_type_int, (LONGEST) 0));
+  set_internalvar (lookup_internalvar ("trace_frame"),
+		   value_from_longest (builtin_type_int, (LONGEST) - 1));
+
+  if (tracepoint_list.list == NULL)
+    {
+      tracepoint_list.listsize = 128;
+      tracepoint_list.list = xmalloc
+	(tracepoint_list.listsize * sizeof (struct memrange));
+    }
+  if (tracepoint_list.aexpr_list == NULL)
+    {
+      tracepoint_list.aexpr_listsize = 128;
+      tracepoint_list.aexpr_list = xmalloc
+	(tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
+    }
+
+  if (stepping_list.list == NULL)
+    {
+      stepping_list.listsize = 128;
+      stepping_list.list = xmalloc
+	(stepping_list.listsize * sizeof (struct memrange));
+    }
+
+  if (stepping_list.aexpr_list == NULL)
+    {
+      stepping_list.aexpr_listsize = 128;
+      stepping_list.aexpr_list = xmalloc
+	(stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
+    }
+
+  add_info ("scope", scope_info,
+	    "List the variables local to a scope");
+
+  add_cmd ("tracepoints", class_trace, NULL,
+	   "Tracing of program execution without stopping the program.",
+	   &cmdlist);
+
+  add_info ("tracepoints", tracepoints_info,
+	    "Status of tracepoints, or tracepoint number NUMBER.\n\
+Convenience variable \"$tpnum\" contains the number of the\n\
+last tracepoint set.");
+
+  add_info_alias ("tp", "tracepoints", 1);
+
+  c = add_com ("save-tracepoints", class_trace, tracepoint_save_command,
+	       "Save current tracepoint definitions as a script.\n\
+Use the 'source' command in another debug session to restore them.");
+  set_cmd_completer (c, filename_completer);
+
+  add_com ("tdump", class_trace, trace_dump_command,
+	   "Print everything collected at the current tracepoint.");
+
+  add_prefix_cmd ("tfind", class_trace, trace_find_command,
+		  "Select a trace frame;\n\
+No argument means forward by one frame; '-' meand backward by one frame.",
+		  &tfindlist, "tfind ", 1, &cmdlist);
+
+  add_cmd ("outside", class_trace, trace_find_outside_command,
+	   "Select a trace frame whose PC is outside the given \
+range.\nUsage: tfind outside addr1, addr2",
+	   &tfindlist);
+
+  add_cmd ("range", class_trace, trace_find_range_command,
+	   "Select a trace frame whose PC is in the given range.\n\
+Usage: tfind range addr1,addr2",
+	   &tfindlist);
+
+  add_cmd ("line", class_trace, trace_find_line_command,
+	   "Select a trace frame by source line.\n\
+Argument can be a line number (with optional source file), \n\
+a function name, or '*' followed by an address.\n\
+Default argument is 'the next source line that was traced'.",
+	   &tfindlist);
+
+  add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command,
+	   "Select a trace frame by tracepoint number.\n\
+Default is the tracepoint for the current trace frame.",
+	   &tfindlist);
+
+  add_cmd ("pc", class_trace, trace_find_pc_command,
+	   "Select a trace frame by PC.\n\
+Default is the current PC, or the PC of the current trace frame.",
+	   &tfindlist);
+
+  add_cmd ("end", class_trace, trace_find_end_command,
+	   "Synonym for 'none'.\n\
+De-select any trace frame and resume 'live' debugging.",
+	   &tfindlist);
+
+  add_cmd ("none", class_trace, trace_find_none_command,
+	   "De-select any trace frame and resume 'live' debugging.",
+	   &tfindlist);
+
+  add_cmd ("start", class_trace, trace_find_start_command,
+	   "Select the first trace frame in the trace buffer.",
+	   &tfindlist);
+
+  add_com ("tstatus", class_trace, trace_status_command,
+	   "Display the status of the current trace data collection.");
+
+  add_com ("tstop", class_trace, trace_stop_command,
+	   "Stop trace data collection.");
+
+  add_com ("tstart", class_trace, trace_start_command,
+	   "Start trace data collection.");
+
+  add_com ("passcount", class_trace, trace_pass_command,
+	   "Set the passcount for a tracepoint.\n\
+The trace will end when the tracepoint has been passed 'count' times.\n\
+Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
+if TPNUM is omitted, passcount refers to the last tracepoint defined.");
+
+  add_com ("end", class_trace, end_actions_pseudocommand,
+	   "Ends a list of commands or actions.\n\
+Several GDB commands allow you to enter a list of commands or actions.\n\
+Entering \"end\" on a line by itself is the normal way to terminate\n\
+such a list.\n\n\
+Note: the \"end\" command cannot be used at the gdb prompt.");
+
+  add_com ("while-stepping", class_trace, while_stepping_pseudocommand,
+	   "Specify single-stepping behavior at a tracepoint.\n\
+Argument is number of instructions to trace in single-step mode\n\
+following the tracepoint.  This command is normally followed by\n\
+one or more \"collect\" commands, to specify what to collect\n\
+while single-stepping.\n\n\
+Note: this command can only be used in a tracepoint \"actions\" list.");
+
+  add_com_alias ("ws", "while-stepping", class_alias, 0);
+  add_com_alias ("stepping", "while-stepping", class_alias, 0);
+
+  add_com ("collect", class_trace, collect_pseudocommand,
+	   "Specify one or more data items to be collected at a tracepoint.\n\
+Accepts a comma-separated list of (one or more) expressions.  GDB will\n\
+collect all data (variables, registers) referenced by that expression.\n\
+Also accepts the following special arguments:\n\
+    $regs   -- all registers.\n\
+    $args   -- all function arguments.\n\
+    $locals -- all variables local to the block/function scope.\n\
+Note: this command can only be used in a tracepoint \"actions\" list.");
+
+  add_com ("actions", class_trace, trace_actions_command,
+	   "Specify the actions to be taken at a tracepoint.\n\
+Tracepoint actions may include collecting of specified data, \n\
+single-stepping, or enabling/disabling other tracepoints, \n\
+depending on target's capabilities.");
+
+  add_cmd ("tracepoints", class_trace, delete_trace_command,
+	   "Delete specified tracepoints.\n\
+Arguments are tracepoint numbers, separated by spaces.\n\
+No argument means delete all tracepoints.",
+	   &deletelist);
+
+  add_cmd ("tracepoints", class_trace, disable_trace_command,
+	   "Disable specified tracepoints.\n\
+Arguments are tracepoint numbers, separated by spaces.\n\
+No argument means disable all tracepoints.",
+	   &disablelist);
+
+  add_cmd ("tracepoints", class_trace, enable_trace_command,
+	   "Enable specified tracepoints.\n\
+Arguments are tracepoint numbers, separated by spaces.\n\
+No argument means enable all tracepoints.",
+	   &enablelist);
+
+  c = add_com ("trace", class_trace, trace_command,
+	       "Set a tracepoint at a specified line or function or address.\n\
+Argument may be a line number, function name, or '*' plus an address.\n\
+For a line number or function, trace at the start of its code.\n\
+If an address is specified, trace at that exact address.\n\n\
+Do \"help tracepoints\" for info on other tracepoint commands.");
+  set_cmd_completer (c, location_completer);
+
+  add_com_alias ("tp", "trace", class_alias, 0);
+  add_com_alias ("tr", "trace", class_alias, 1);
+  add_com_alias ("tra", "trace", class_alias, 1);
+  add_com_alias ("trac", "trace", class_alias, 1);
+}
diff --git a/gdb/valops.c b/gdb/valops.c
new file mode 100644
index 0000000..eaf4295
--- /dev/null
+++ b/gdb/valops.c
@@ -0,0 +1,3536 @@
+/* Perform non-arithmetic operations on values, for GDB.
+   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
+   Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "value.h"
+#include "frame.h"
+#include "inferior.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "demangle.h"
+#include "language.h"
+#include "gdbcmd.h"
+#include "regcache.h"
+#include "cp-abi.h"
+
+#include <errno.h>
+#include "gdb_string.h"
+#include "gdb_assert.h"
+
+/* Flag indicating HP compilers were used; needed to correctly handle some
+   value operations with HP aCC code/runtime. */
+extern int hp_som_som_object_present;
+
+extern int overload_debug;
+/* Local functions.  */
+
+static int typecmp (int staticp, int varargs, int nargs,
+		    struct field t1[], struct value *t2[]);
+
+static CORE_ADDR find_function_addr (struct value *, struct type **);
+static struct value *value_arg_coerce (struct value *, struct type *, int);
+
+
+static CORE_ADDR value_push (CORE_ADDR, struct value *);
+
+static struct value *search_struct_field (char *, struct value *, int,
+				      struct type *, int);
+
+static struct value *search_struct_method (char *, struct value **,
+				       struct value **,
+				       int, int *, struct type *);
+
+static int check_field_in (struct type *, const char *);
+
+static CORE_ADDR allocate_space_in_inferior (int);
+
+static struct value *cast_into_complex (struct type *, struct value *);
+
+static struct fn_field *find_method_list (struct value ** argp, char *method,
+					  int offset,
+					  struct type *type, int *num_fns,
+					  struct type **basetype,
+					  int *boffset);
+
+void _initialize_valops (void);
+
+/* Flag for whether we want to abandon failed expression evals by default.  */
+
+#if 0
+static int auto_abandon = 0;
+#endif
+
+int overload_resolution = 0;
+
+/* This boolean tells what gdb should do if a signal is received while in
+   a function called from gdb (call dummy).  If set, gdb unwinds the stack
+   and restore the context to what as it was before the call.
+   The default is to stop in the frame where the signal was received. */
+
+int unwind_on_signal_p = 0;
+
+
+
+/* Find the address of function name NAME in the inferior.  */
+
+struct value *
+find_function_in_inferior (const char *name)
+{
+  register struct symbol *sym;
+  sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
+  if (sym != NULL)
+    {
+      if (SYMBOL_CLASS (sym) != LOC_BLOCK)
+	{
+	  error ("\"%s\" exists in this program but is not a function.",
+		 name);
+	}
+      return value_of_variable (sym, NULL);
+    }
+  else
+    {
+      struct minimal_symbol *msymbol = lookup_minimal_symbol (name, NULL, NULL);
+      if (msymbol != NULL)
+	{
+	  struct type *type;
+	  CORE_ADDR maddr;
+	  type = lookup_pointer_type (builtin_type_char);
+	  type = lookup_function_type (type);
+	  type = lookup_pointer_type (type);
+	  maddr = SYMBOL_VALUE_ADDRESS (msymbol);
+	  return value_from_pointer (type, maddr);
+	}
+      else
+	{
+	  if (!target_has_execution)
+	    error ("evaluation of this expression requires the target program to be active");
+	  else
+	    error ("evaluation of this expression requires the program to have a function \"%s\".", name);
+	}
+    }
+}
+
+/* Allocate NBYTES of space in the inferior using the inferior's malloc
+   and return a value that is a pointer to the allocated space. */
+
+struct value *
+value_allocate_space_in_inferior (int len)
+{
+  struct value *blocklen;
+  struct value *val = find_function_in_inferior (NAME_OF_MALLOC);
+
+  blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
+  val = call_function_by_hand (val, 1, &blocklen);
+  if (value_logical_not (val))
+    {
+      if (!target_has_execution)
+	error ("No memory available to program now: you need to start the target first");
+      else
+	error ("No memory available to program: call to malloc failed");
+    }
+  return val;
+}
+
+static CORE_ADDR
+allocate_space_in_inferior (int len)
+{
+  return value_as_long (value_allocate_space_in_inferior (len));
+}
+
+/* Cast value ARG2 to type TYPE and return as a value.
+   More general than a C cast: accepts any two types of the same length,
+   and if ARG2 is an lvalue it can be cast into anything at all.  */
+/* In C++, casts may change pointer or object representations.  */
+
+struct value *
+value_cast (struct type *type, struct value *arg2)
+{
+  register enum type_code code1;
+  register enum type_code code2;
+  register int scalar;
+  struct type *type2;
+
+  int convert_to_boolean = 0;
+
+  if (VALUE_TYPE (arg2) == type)
+    return arg2;
+
+  CHECK_TYPEDEF (type);
+  code1 = TYPE_CODE (type);
+  COERCE_REF (arg2);
+  type2 = check_typedef (VALUE_TYPE (arg2));
+
+  /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
+     is treated like a cast to (TYPE [N])OBJECT,
+     where N is sizeof(OBJECT)/sizeof(TYPE). */
+  if (code1 == TYPE_CODE_ARRAY)
+    {
+      struct type *element_type = TYPE_TARGET_TYPE (type);
+      unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
+      if (element_length > 0
+	&& TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
+	{
+	  struct type *range_type = TYPE_INDEX_TYPE (type);
+	  int val_length = TYPE_LENGTH (type2);
+	  LONGEST low_bound, high_bound, new_length;
+	  if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
+	    low_bound = 0, high_bound = 0;
+	  new_length = val_length / element_length;
+	  if (val_length % element_length != 0)
+	    warning ("array element type size does not divide object size in cast");
+	  /* FIXME-type-allocation: need a way to free this type when we are
+	     done with it.  */
+	  range_type = create_range_type ((struct type *) NULL,
+					  TYPE_TARGET_TYPE (range_type),
+					  low_bound,
+					  new_length + low_bound - 1);
+	  VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
+						 element_type, range_type);
+	  return arg2;
+	}
+    }
+
+  if (current_language->c_style_arrays
+      && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
+    arg2 = value_coerce_array (arg2);
+
+  if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
+    arg2 = value_coerce_function (arg2);
+
+  type2 = check_typedef (VALUE_TYPE (arg2));
+  COERCE_VARYING_ARRAY (arg2, type2);
+  code2 = TYPE_CODE (type2);
+
+  if (code1 == TYPE_CODE_COMPLEX)
+    return cast_into_complex (type, arg2);
+  if (code1 == TYPE_CODE_BOOL)
+    {
+      code1 = TYPE_CODE_INT;
+      convert_to_boolean = 1;
+    }
+  if (code1 == TYPE_CODE_CHAR)
+    code1 = TYPE_CODE_INT;
+  if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
+    code2 = TYPE_CODE_INT;
+
+  scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
+	    || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
+
+  if (code1 == TYPE_CODE_STRUCT
+      && code2 == TYPE_CODE_STRUCT
+      && TYPE_NAME (type) != 0)
+    {
+      /* Look in the type of the source to see if it contains the
+         type of the target as a superclass.  If so, we'll need to
+         offset the object in addition to changing its type.  */
+      struct value *v = search_struct_field (type_name_no_tag (type),
+					 arg2, 0, type2, 1);
+      if (v)
+	{
+	  VALUE_TYPE (v) = type;
+	  return v;
+	}
+    }
+  if (code1 == TYPE_CODE_FLT && scalar)
+    return value_from_double (type, value_as_double (arg2));
+  else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
+	    || code1 == TYPE_CODE_RANGE)
+	   && (scalar || code2 == TYPE_CODE_PTR))
+    {
+      LONGEST longest;
+
+      if (hp_som_som_object_present &&	/* if target compiled by HP aCC */
+	  (code2 == TYPE_CODE_PTR))
+	{
+	  unsigned int *ptr;
+	  struct value *retvalp;
+
+	  switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
+	    {
+	      /* With HP aCC, pointers to data members have a bias */
+	    case TYPE_CODE_MEMBER:
+	      retvalp = value_from_longest (type, value_as_long (arg2));
+	      /* force evaluation */
+	      ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
+	      *ptr &= ~0x20000000;	/* zap 29th bit to remove bias */
+	      return retvalp;
+
+	      /* While pointers to methods don't really point to a function */
+	    case TYPE_CODE_METHOD:
+	      error ("Pointers to methods not supported with HP aCC");
+
+	    default:
+	      break;		/* fall out and go to normal handling */
+	    }
+	}
+
+      /* When we cast pointers to integers, we mustn't use
+         POINTER_TO_ADDRESS to find the address the pointer
+         represents, as value_as_long would.  GDB should evaluate
+         expressions just as the compiler would --- and the compiler
+         sees a cast as a simple reinterpretation of the pointer's
+         bits.  */
+      if (code2 == TYPE_CODE_PTR)
+        longest = extract_unsigned_integer (VALUE_CONTENTS (arg2),
+                                            TYPE_LENGTH (type2));
+      else
+        longest = value_as_long (arg2);
+      return value_from_longest (type, convert_to_boolean ?
+				 (LONGEST) (longest ? 1 : 0) : longest);
+    }
+  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT  ||
+				      code2 == TYPE_CODE_ENUM ||
+				      code2 == TYPE_CODE_RANGE))
+    {
+      /* TYPE_LENGTH (type) is the length of a pointer, but we really
+	 want the length of an address! -- we are really dealing with
+	 addresses (i.e., gdb representations) not pointers (i.e.,
+	 target representations) here.
+
+	 This allows things like "print *(int *)0x01000234" to work
+	 without printing a misleading message -- which would
+	 otherwise occur when dealing with a target having two byte
+	 pointers and four byte addresses.  */
+
+      int addr_bit = TARGET_ADDR_BIT;
+
+      LONGEST longest = value_as_long (arg2);
+      if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
+	{
+	  if (longest >= ((LONGEST) 1 << addr_bit)
+	      || longest <= -((LONGEST) 1 << addr_bit))
+	    warning ("value truncated");
+	}
+      return value_from_longest (type, longest);
+    }
+  else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
+    {
+      if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
+	{
+	  struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
+	  struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
+	  if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
+	      && TYPE_CODE (t2) == TYPE_CODE_STRUCT
+	      && !value_logical_not (arg2))
+	    {
+	      struct value *v;
+
+	      /* Look in the type of the source to see if it contains the
+	         type of the target as a superclass.  If so, we'll need to
+	         offset the pointer rather than just change its type.  */
+	      if (TYPE_NAME (t1) != NULL)
+		{
+		  v = search_struct_field (type_name_no_tag (t1),
+					   value_ind (arg2), 0, t2, 1);
+		  if (v)
+		    {
+		      v = value_addr (v);
+		      VALUE_TYPE (v) = type;
+		      return v;
+		    }
+		}
+
+	      /* Look in the type of the target to see if it contains the
+	         type of the source as a superclass.  If so, we'll need to
+	         offset the pointer rather than just change its type.
+	         FIXME: This fails silently with virtual inheritance.  */
+	      if (TYPE_NAME (t2) != NULL)
+		{
+		  v = search_struct_field (type_name_no_tag (t2),
+				       value_zero (t1, not_lval), 0, t1, 1);
+		  if (v)
+		    {
+                      CORE_ADDR addr2 = value_as_address (arg2);
+                      addr2 -= (VALUE_ADDRESS (v)
+                                + VALUE_OFFSET (v)
+                                + VALUE_EMBEDDED_OFFSET (v));
+                      return value_from_pointer (type, addr2);
+		    }
+		}
+	    }
+	  /* No superclass found, just fall through to change ptr type.  */
+	}
+      VALUE_TYPE (arg2) = type;
+      arg2 = value_change_enclosing_type (arg2, type);
+      VALUE_POINTED_TO_OFFSET (arg2) = 0;	/* pai: chk_val */
+      return arg2;
+    }
+  /* OBSOLETE else if (chill_varying_type (type)) */
+  /* OBSOLETE   { */
+  /* OBSOLETE     struct type *range1, *range2, *eltype1, *eltype2; */
+  /* OBSOLETE     struct value *val; */
+  /* OBSOLETE     int count1, count2; */
+  /* OBSOLETE     LONGEST low_bound, high_bound; */
+  /* OBSOLETE     char *valaddr, *valaddr_data; */
+  /* OBSOLETE     *//* For lint warning about eltype2 possibly uninitialized: */
+  /* OBSOLETE     eltype2 = NULL; */
+  /* OBSOLETE     if (code2 == TYPE_CODE_BITSTRING) */
+  /* OBSOLETE       error ("not implemented: converting bitstring to varying type"); */
+  /* OBSOLETE     if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING) */
+  /* OBSOLETE         || (eltype1 = check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1))), */
+  /* OBSOLETE       eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)), */
+  /* OBSOLETE                                (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2) */
+  /* OBSOLETE     *//*|| TYPE_CODE (eltype1) != TYPE_CODE (eltype2) *//* ))) */
+  /* OBSOLETE      error ("Invalid conversion to varying type"); */
+  /* OBSOLETE     range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0); */
+  /* OBSOLETE     range2 = TYPE_FIELD_TYPE (type2, 0); */
+  /* OBSOLETE     if (get_discrete_bounds (range1, &low_bound, &high_bound) < 0) */
+  /* OBSOLETE       count1 = -1; */
+  /* OBSOLETE     else */
+  /* OBSOLETE       count1 = high_bound - low_bound + 1; */
+  /* OBSOLETE     if (get_discrete_bounds (range2, &low_bound, &high_bound) < 0) */
+  /* OBSOLETE       count1 = -1, count2 = 0;	*//* To force error before */
+  /* OBSOLETE     else */
+  /* OBSOLETE       count2 = high_bound - low_bound + 1; */
+  /* OBSOLETE     if (count2 > count1) */
+  /* OBSOLETE       error ("target varying type is too small"); */
+  /* OBSOLETE     val = allocate_value (type); */
+  /* OBSOLETE     valaddr = VALUE_CONTENTS_RAW (val); */
+  /* OBSOLETE     valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8; */
+  /* OBSOLETE     *//* Set val's __var_length field to count2. */
+  /* OBSOLETE     store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)), */
+  /* OBSOLETE 	    count2); */
+  /* OBSOLETE     *//* Set the __var_data field to count2 elements copied from arg2. */
+  /* OBSOLETE     memcpy (valaddr_data, VALUE_CONTENTS (arg2), */
+  /* OBSOLETE      count2 * TYPE_LENGTH (eltype2)); */
+  /* OBSOLETE     *//* Zero the rest of the __var_data field of val. */
+  /* OBSOLETE     memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0', */
+  /* OBSOLETE      (count1 - count2) * TYPE_LENGTH (eltype2)); */
+  /* OBSOLETE     return val; */
+  /* OBSOLETE   } */
+  else if (VALUE_LVAL (arg2) == lval_memory)
+    {
+      return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2),
+			    VALUE_BFD_SECTION (arg2));
+    }
+  else if (code1 == TYPE_CODE_VOID)
+    {
+      return value_zero (builtin_type_void, not_lval);
+    }
+  else
+    {
+      error ("Invalid cast.");
+      return 0;
+    }
+}
+
+/* Create a value of type TYPE that is zero, and return it.  */
+
+struct value *
+value_zero (struct type *type, enum lval_type lv)
+{
+  struct value *val = allocate_value (type);
+
+  memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
+  VALUE_LVAL (val) = lv;
+
+  return val;
+}
+
+/* Return a value with type TYPE located at ADDR.
+
+   Call value_at only if the data needs to be fetched immediately;
+   if we can be 'lazy' and defer the fetch, perhaps indefinately, call
+   value_at_lazy instead.  value_at_lazy simply records the address of
+   the data and sets the lazy-evaluation-required flag.  The lazy flag
+   is tested in the VALUE_CONTENTS macro, which is used if and when
+   the contents are actually required.
+
+   Note: value_at does *NOT* handle embedded offsets; perform such
+   adjustments before or after calling it. */
+
+struct value *
+value_at (struct type *type, CORE_ADDR addr, asection *sect)
+{
+  struct value *val;
+
+  if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
+    error ("Attempt to dereference a generic pointer.");
+
+  val = allocate_value (type);
+
+  read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
+
+  VALUE_LVAL (val) = lval_memory;
+  VALUE_ADDRESS (val) = addr;
+  VALUE_BFD_SECTION (val) = sect;
+
+  return val;
+}
+
+/* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
+
+struct value *
+value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
+{
+  struct value *val;
+
+  if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
+    error ("Attempt to dereference a generic pointer.");
+
+  val = allocate_value (type);
+
+  VALUE_LVAL (val) = lval_memory;
+  VALUE_ADDRESS (val) = addr;
+  VALUE_LAZY (val) = 1;
+  VALUE_BFD_SECTION (val) = sect;
+
+  return val;
+}
+
+/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
+   if the current data for a variable needs to be loaded into
+   VALUE_CONTENTS(VAL).  Fetches the data from the user's process, and
+   clears the lazy flag to indicate that the data in the buffer is valid.
+
+   If the value is zero-length, we avoid calling read_memory, which would
+   abort.  We mark the value as fetched anyway -- all 0 bytes of it.
+
+   This function returns a value because it is used in the VALUE_CONTENTS
+   macro as part of an expression, where a void would not work.  The
+   value is ignored.  */
+
+int
+value_fetch_lazy (struct value *val)
+{
+  CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
+  int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
+
+  struct type *type = VALUE_TYPE (val);
+  if (length)
+    read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
+
+  VALUE_LAZY (val) = 0;
+  return 0;
+}
+
+
+/* Store the contents of FROMVAL into the location of TOVAL.
+   Return a new value with the location of TOVAL and contents of FROMVAL.  */
+
+struct value *
+value_assign (struct value *toval, struct value *fromval)
+{
+  register struct type *type;
+  struct value *val;
+  char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  int use_buffer = 0;
+
+  if (!toval->modifiable)
+    error ("Left operand of assignment is not a modifiable lvalue.");
+
+  COERCE_REF (toval);
+
+  type = VALUE_TYPE (toval);
+  if (VALUE_LVAL (toval) != lval_internalvar)
+    fromval = value_cast (type, fromval);
+  else
+    COERCE_ARRAY (fromval);
+  CHECK_TYPEDEF (type);
+
+  /* If TOVAL is a special machine register requiring conversion
+     of program values to a special raw format,
+     convert FROMVAL's contents now, with result in `raw_buffer',
+     and set USE_BUFFER to the number of bytes to write.  */
+
+  if (VALUE_REGNO (toval) >= 0)
+    {
+      int regno = VALUE_REGNO (toval);
+      if (CONVERT_REGISTER_P (regno))
+	{
+	  struct type *fromtype = check_typedef (VALUE_TYPE (fromval));
+	  VALUE_TO_REGISTER (fromtype, regno, VALUE_CONTENTS (fromval), raw_buffer);
+	  use_buffer = REGISTER_RAW_SIZE (regno);
+	}
+    }
+
+  switch (VALUE_LVAL (toval))
+    {
+    case lval_internalvar:
+      set_internalvar (VALUE_INTERNALVAR (toval), fromval);
+      val = value_copy (VALUE_INTERNALVAR (toval)->value);
+      val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
+      VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
+      VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
+      return val;
+
+    case lval_internalvar_component:
+      set_internalvar_component (VALUE_INTERNALVAR (toval),
+				 VALUE_OFFSET (toval),
+				 VALUE_BITPOS (toval),
+				 VALUE_BITSIZE (toval),
+				 fromval);
+      break;
+
+    case lval_memory:
+      {
+	char *dest_buffer;
+	CORE_ADDR changed_addr;
+	int changed_len;
+
+	if (VALUE_BITSIZE (toval))
+	  {
+	    char buffer[sizeof (LONGEST)];
+	    /* We assume that the argument to read_memory is in units of
+	       host chars.  FIXME:  Is that correct?  */
+	    changed_len = (VALUE_BITPOS (toval)
+			   + VALUE_BITSIZE (toval)
+			   + HOST_CHAR_BIT - 1)
+	      / HOST_CHAR_BIT;
+
+	    if (changed_len > (int) sizeof (LONGEST))
+	      error ("Can't handle bitfields which don't fit in a %d bit word.",
+		     (int) sizeof (LONGEST) * HOST_CHAR_BIT);
+
+	    read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+			 buffer, changed_len);
+	    modify_field (buffer, value_as_long (fromval),
+			  VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
+	    changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
+	    dest_buffer = buffer;
+	  }
+	else if (use_buffer)
+	  {
+	    changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
+	    changed_len = use_buffer;
+	    dest_buffer = raw_buffer;
+	  }
+	else
+	  {
+	    changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
+	    changed_len = TYPE_LENGTH (type);
+	    dest_buffer = VALUE_CONTENTS (fromval);
+	  }
+
+	write_memory (changed_addr, dest_buffer, changed_len);
+	if (memory_changed_hook)
+	  memory_changed_hook (changed_addr, changed_len);
+	target_changed_event ();
+      }
+      break;
+
+    case lval_register:
+      if (VALUE_BITSIZE (toval))
+	{
+	  char buffer[sizeof (LONGEST)];
+	  int len =
+		REGISTER_RAW_SIZE (VALUE_REGNO (toval)) - VALUE_OFFSET (toval);
+
+	  if (len > (int) sizeof (LONGEST))
+	    error ("Can't handle bitfields in registers larger than %d bits.",
+		   (int) sizeof (LONGEST) * HOST_CHAR_BIT);
+
+	  if (VALUE_BITPOS (toval) + VALUE_BITSIZE (toval)
+	      > len * HOST_CHAR_BIT)
+	    /* Getting this right would involve being very careful about
+	       byte order.  */
+	    error ("Can't assign to bitfields that cross register "
+		   "boundaries.");
+
+	  read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+			       buffer, len);
+	  modify_field (buffer, value_as_long (fromval),
+			VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
+	  write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+				buffer, len);
+	}
+      else if (use_buffer)
+	write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+			      raw_buffer, use_buffer);
+      else
+	{
+	  /* Do any conversion necessary when storing this type to more
+	     than one register.  */
+#ifdef REGISTER_CONVERT_FROM_TYPE
+	  memcpy (raw_buffer, VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
+	  REGISTER_CONVERT_FROM_TYPE (VALUE_REGNO (toval), type, raw_buffer);
+	  write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+				raw_buffer, TYPE_LENGTH (type));
+#else
+	  write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+			      VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
+#endif
+	}
+
+      target_changed_event ();
+
+      /* Assigning to the stack pointer, frame pointer, and other
+         (architecture and calling convention specific) registers may
+         cause the frame cache to be out of date.  We just do this
+         on all assignments to registers for simplicity; I doubt the slowdown
+         matters.  */
+      reinit_frame_cache ();
+      break;
+
+    case lval_reg_frame_relative:
+      {
+	/* value is stored in a series of registers in the frame
+	   specified by the structure.  Copy that value out, modify
+	   it, and copy it back in.  */
+	int amount_to_copy = (VALUE_BITSIZE (toval) ? 1 : TYPE_LENGTH (type));
+	int reg_size = REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval));
+	int byte_offset = VALUE_OFFSET (toval) % reg_size;
+	int reg_offset = VALUE_OFFSET (toval) / reg_size;
+	int amount_copied;
+
+	/* Make the buffer large enough in all cases.  */
+	/* FIXME (alloca): Not safe for very large data types. */
+	char *buffer = (char *) alloca (amount_to_copy
+					+ sizeof (LONGEST)
+					+ MAX_REGISTER_RAW_SIZE);
+
+	int regno;
+	struct frame_info *frame;
+
+	/* Figure out which frame this is in currently.  */
+	for (frame = get_current_frame ();
+	     frame && FRAME_FP (frame) != VALUE_FRAME (toval);
+	     frame = get_prev_frame (frame))
+	  ;
+
+	if (!frame)
+	  error ("Value being assigned to is no longer active.");
+
+	amount_to_copy += (reg_size - amount_to_copy % reg_size);
+
+	/* Copy it out.  */
+	for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
+	      amount_copied = 0);
+	     amount_copied < amount_to_copy;
+	     amount_copied += reg_size, regno++)
+	  {
+	    get_saved_register (buffer + amount_copied,
+				(int *) NULL, (CORE_ADDR *) NULL,
+				frame, regno, (enum lval_type *) NULL);
+	  }
+
+	/* Modify what needs to be modified.  */
+	if (VALUE_BITSIZE (toval))
+	  modify_field (buffer + byte_offset,
+			value_as_long (fromval),
+			VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
+	else if (use_buffer)
+	  memcpy (buffer + byte_offset, raw_buffer, use_buffer);
+	else
+	  memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
+		  TYPE_LENGTH (type));
+
+	/* Copy it back.  */
+	for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
+	      amount_copied = 0);
+	     amount_copied < amount_to_copy;
+	     amount_copied += reg_size, regno++)
+	  {
+	    enum lval_type lval;
+	    CORE_ADDR addr;
+	    int optim;
+
+	    /* Just find out where to put it.  */
+	    get_saved_register ((char *) NULL,
+				&optim, &addr, frame, regno, &lval);
+
+	    if (optim)
+	      error ("Attempt to assign to a value that was optimized out.");
+	    if (lval == lval_memory)
+	      write_memory (addr, buffer + amount_copied, reg_size);
+	    else if (lval == lval_register)
+	      write_register_bytes (addr, buffer + amount_copied, reg_size);
+	    else
+	      error ("Attempt to assign to an unmodifiable value.");
+	  }
+
+	if (register_changed_hook)
+	  register_changed_hook (-1);
+	target_changed_event ();
+      }
+      break;
+
+
+    default:
+      error ("Left operand of assignment is not an lvalue.");
+    }
+
+  /* If the field does not entirely fill a LONGEST, then zero the sign bits.
+     If the field is signed, and is negative, then sign extend. */
+  if ((VALUE_BITSIZE (toval) > 0)
+      && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST)))
+    {
+      LONGEST fieldval = value_as_long (fromval);
+      LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
+
+      fieldval &= valmask;
+      if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
+	fieldval |= ~valmask;
+
+      fromval = value_from_longest (type, fieldval);
+    }
+
+  val = value_copy (toval);
+  memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
+	  TYPE_LENGTH (type));
+  VALUE_TYPE (val) = type;
+  val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
+  VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
+  VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
+
+  return val;
+}
+
+/* Extend a value VAL to COUNT repetitions of its type.  */
+
+struct value *
+value_repeat (struct value *arg1, int count)
+{
+  struct value *val;
+
+  if (VALUE_LVAL (arg1) != lval_memory)
+    error ("Only values in memory can be extended with '@'.");
+  if (count < 1)
+    error ("Invalid number %d of repetitions.", count);
+
+  val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count);
+
+  read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
+	       VALUE_CONTENTS_ALL_RAW (val),
+	       TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)));
+  VALUE_LVAL (val) = lval_memory;
+  VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
+
+  return val;
+}
+
+struct value *
+value_of_variable (struct symbol *var, struct block *b)
+{
+  struct value *val;
+  struct frame_info *frame = NULL;
+
+  if (!b)
+    frame = NULL;		/* Use selected frame.  */
+  else if (symbol_read_needs_frame (var))
+    {
+      frame = block_innermost_frame (b);
+      if (!frame)
+	{
+	  if (BLOCK_FUNCTION (b)
+	      && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)))
+	    error ("No frame is currently executing in block %s.",
+		   SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)));
+	  else
+	    error ("No frame is currently executing in specified block");
+	}
+    }
+
+  val = read_var_value (var, frame);
+  if (!val)
+    error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
+
+  return val;
+}
+
+/* Given a value which is an array, return a value which is a pointer to its
+   first element, regardless of whether or not the array has a nonzero lower
+   bound.
+
+   FIXME:  A previous comment here indicated that this routine should be
+   substracting the array's lower bound.  It's not clear to me that this
+   is correct.  Given an array subscripting operation, it would certainly
+   work to do the adjustment here, essentially computing:
+
+   (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
+
+   However I believe a more appropriate and logical place to account for
+   the lower bound is to do so in value_subscript, essentially computing:
+
+   (&array[0] + ((index - lowerbound) * sizeof array[0]))
+
+   As further evidence consider what would happen with operations other
+   than array subscripting, where the caller would get back a value that
+   had an address somewhere before the actual first element of the array,
+   and the information about the lower bound would be lost because of
+   the coercion to pointer type.
+ */
+
+struct value *
+value_coerce_array (struct value *arg1)
+{
+  register struct type *type = check_typedef (VALUE_TYPE (arg1));
+
+  if (VALUE_LVAL (arg1) != lval_memory)
+    error ("Attempt to take address of value not located in memory.");
+
+  return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
+			     (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
+}
+
+/* Given a value which is a function, return a value which is a pointer
+   to it.  */
+
+struct value *
+value_coerce_function (struct value *arg1)
+{
+  struct value *retval;
+
+  if (VALUE_LVAL (arg1) != lval_memory)
+    error ("Attempt to take address of value not located in memory.");
+
+  retval = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
+			       (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
+  VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1);
+  return retval;
+}
+
+/* Return a pointer value for the object for which ARG1 is the contents.  */
+
+struct value *
+value_addr (struct value *arg1)
+{
+  struct value *arg2;
+
+  struct type *type = check_typedef (VALUE_TYPE (arg1));
+  if (TYPE_CODE (type) == TYPE_CODE_REF)
+    {
+      /* Copy the value, but change the type from (T&) to (T*).
+         We keep the same location information, which is efficient,
+         and allows &(&X) to get the location containing the reference. */
+      arg2 = value_copy (arg1);
+      VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+      return arg2;
+    }
+  if (TYPE_CODE (type) == TYPE_CODE_FUNC)
+    return value_coerce_function (arg1);
+
+  if (VALUE_LVAL (arg1) != lval_memory)
+    error ("Attempt to take address of value not located in memory.");
+
+  /* Get target memory address */
+  arg2 = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
+			     (VALUE_ADDRESS (arg1)
+			      + VALUE_OFFSET (arg1)
+			      + VALUE_EMBEDDED_OFFSET (arg1)));
+
+  /* This may be a pointer to a base subobject; so remember the
+     full derived object's type ... */
+  arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)));
+  /* ... and also the relative position of the subobject in the full object */
+  VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
+  VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1);
+  return arg2;
+}
+
+/* Given a value of a pointer type, apply the C unary * operator to it.  */
+
+struct value *
+value_ind (struct value *arg1)
+{
+  struct type *base_type;
+  struct value *arg2;
+
+  COERCE_ARRAY (arg1);
+
+  base_type = check_typedef (VALUE_TYPE (arg1));
+
+  if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
+    error ("not implemented: member types in value_ind");
+
+  /* Allow * on an integer so we can cast it to whatever we want.
+     This returns an int, which seems like the most C-like thing
+     to do.  "long long" variables are rare enough that
+     BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
+  if (TYPE_CODE (base_type) == TYPE_CODE_INT)
+    return value_at_lazy (builtin_type_int,
+			  (CORE_ADDR) value_as_long (arg1),
+			  VALUE_BFD_SECTION (arg1));
+  else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
+    {
+      struct type *enc_type;
+      /* We may be pointing to something embedded in a larger object */
+      /* Get the real type of the enclosing object */
+      enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1));
+      enc_type = TYPE_TARGET_TYPE (enc_type);
+      /* Retrieve the enclosing object pointed to */
+      arg2 = value_at_lazy (enc_type,
+		   value_as_address (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
+			    VALUE_BFD_SECTION (arg1));
+      /* Re-adjust type */
+      VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
+      /* Add embedding info */
+      arg2 = value_change_enclosing_type (arg2, enc_type);
+      VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
+
+      /* We may be pointing to an object of some derived type */
+      arg2 = value_full_object (arg2, NULL, 0, 0, 0);
+      return arg2;
+    }
+
+  error ("Attempt to take contents of a non-pointer value.");
+  return 0;			/* For lint -- never reached */
+}
+
+/* Pushing small parts of stack frames.  */
+
+/* Push one word (the size of object that a register holds).  */
+
+CORE_ADDR
+push_word (CORE_ADDR sp, ULONGEST word)
+{
+  register int len = REGISTER_SIZE;
+  char *buffer = alloca (MAX_REGISTER_RAW_SIZE);
+
+  store_unsigned_integer (buffer, len, word);
+  if (INNER_THAN (1, 2))
+    {
+      /* stack grows downward */
+      sp -= len;
+      write_memory (sp, buffer, len);
+    }
+  else
+    {
+      /* stack grows upward */
+      write_memory (sp, buffer, len);
+      sp += len;
+    }
+
+  return sp;
+}
+
+/* Push LEN bytes with data at BUFFER.  */
+
+CORE_ADDR
+push_bytes (CORE_ADDR sp, char *buffer, int len)
+{
+  if (INNER_THAN (1, 2))
+    {
+      /* stack grows downward */
+      sp -= len;
+      write_memory (sp, buffer, len);
+    }
+  else
+    {
+      /* stack grows upward */
+      write_memory (sp, buffer, len);
+      sp += len;
+    }
+
+  return sp;
+}
+
+#ifndef PARM_BOUNDARY
+#define PARM_BOUNDARY (0)
+#endif
+
+/* Push onto the stack the specified value VALUE.  Pad it correctly for
+   it to be an argument to a function.  */
+
+static CORE_ADDR
+value_push (register CORE_ADDR sp, struct value *arg)
+{
+  register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
+  register int container_len = len;
+  register int offset;
+
+  /* How big is the container we're going to put this value in?  */
+  if (PARM_BOUNDARY)
+    container_len = ((len + PARM_BOUNDARY / TARGET_CHAR_BIT - 1)
+		     & ~(PARM_BOUNDARY / TARGET_CHAR_BIT - 1));
+
+  /* Are we going to put it at the high or low end of the container?  */
+  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+    offset = container_len - len;
+  else
+    offset = 0;
+
+  if (INNER_THAN (1, 2))
+    {
+      /* stack grows downward */
+      sp -= container_len;
+      write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
+    }
+  else
+    {
+      /* stack grows upward */
+      write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
+      sp += container_len;
+    }
+
+  return sp;
+}
+
+CORE_ADDR
+default_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
+			int struct_return, CORE_ADDR struct_addr)
+{
+  /* ASSERT ( !struct_return); */
+  int i;
+  for (i = nargs - 1; i >= 0; i--)
+    sp = value_push (sp, args[i]);
+  return sp;
+}
+
+
+/* Functions to use for the COERCE_FLOAT_TO_DOUBLE gdbarch method.
+
+   How you should pass arguments to a function depends on whether it
+   was defined in K&R style or prototype style.  If you define a
+   function using the K&R syntax that takes a `float' argument, then
+   callers must pass that argument as a `double'.  If you define the
+   function using the prototype syntax, then you must pass the
+   argument as a `float', with no promotion.
+
+   Unfortunately, on certain older platforms, the debug info doesn't
+   indicate reliably how each function was defined.  A function type's
+   TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
+   defined in prototype style.  When calling a function whose
+   TYPE_FLAG_PROTOTYPED flag is clear, GDB consults the
+   COERCE_FLOAT_TO_DOUBLE gdbarch method to decide what to do.
+
+   For modern targets, it is proper to assume that, if the prototype
+   flag is clear, that can be trusted: `float' arguments should be
+   promoted to `double'.  You should register the function
+   `standard_coerce_float_to_double' to get this behavior.
+
+   For some older targets, if the prototype flag is clear, that
+   doesn't tell us anything.  So we guess that, if we don't have a
+   type for the formal parameter (i.e., the first argument to
+   COERCE_FLOAT_TO_DOUBLE is null), then we should promote it;
+   otherwise, we should leave it alone.  The function
+   `default_coerce_float_to_double' provides this behavior; it is the
+   default value, for compatibility with older configurations.  */
+int
+default_coerce_float_to_double (struct type *formal, struct type *actual)
+{
+  return formal == NULL;
+}
+
+
+int
+standard_coerce_float_to_double (struct type *formal, struct type *actual)
+{
+  return 1;
+}
+
+
+/* Perform the standard coercions that are specified
+   for arguments to be passed to C functions.
+
+   If PARAM_TYPE is non-NULL, it is the expected parameter type.
+   IS_PROTOTYPED is non-zero if the function declaration is prototyped.  */
+
+static struct value *
+value_arg_coerce (struct value *arg, struct type *param_type,
+		  int is_prototyped)
+{
+  register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
+  register struct type *type
+    = param_type ? check_typedef (param_type) : arg_type;
+
+  switch (TYPE_CODE (type))
+    {
+    case TYPE_CODE_REF:
+      if (TYPE_CODE (arg_type) != TYPE_CODE_REF
+	  && TYPE_CODE (arg_type) != TYPE_CODE_PTR)
+	{
+	  arg = value_addr (arg);
+	  VALUE_TYPE (arg) = param_type;
+	  return arg;
+	}
+      break;
+    case TYPE_CODE_INT:
+    case TYPE_CODE_CHAR:
+    case TYPE_CODE_BOOL:
+    case TYPE_CODE_ENUM:
+      /* If we don't have a prototype, coerce to integer type if necessary.  */
+      if (!is_prototyped)
+	{
+	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
+	    type = builtin_type_int;
+	}
+      /* Currently all target ABIs require at least the width of an integer
+         type for an argument.  We may have to conditionalize the following
+         type coercion for future targets.  */
+      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
+	type = builtin_type_int;
+      break;
+    case TYPE_CODE_FLT:
+      /* FIXME: We should always convert floats to doubles in the
+         non-prototyped case.  As many debugging formats include
+         no information about prototyping, we have to live with
+         COERCE_FLOAT_TO_DOUBLE for now.  */
+      if (!is_prototyped && COERCE_FLOAT_TO_DOUBLE (param_type, arg_type))
+	{
+	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
+	    type = builtin_type_double;
+	  else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
+	    type = builtin_type_long_double;
+	}
+      break;
+    case TYPE_CODE_FUNC:
+      type = lookup_pointer_type (type);
+      break;
+    case TYPE_CODE_ARRAY:
+      /* Arrays are coerced to pointers to their first element, unless
+         they are vectors, in which case we want to leave them alone,
+         because they are passed by value.  */
+      if (current_language->c_style_arrays)
+	if (!TYPE_VECTOR (type))
+	  type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+      break;
+    case TYPE_CODE_UNDEF:
+    case TYPE_CODE_PTR:
+    case TYPE_CODE_STRUCT:
+    case TYPE_CODE_UNION:
+    case TYPE_CODE_VOID:
+    case TYPE_CODE_SET:
+    case TYPE_CODE_RANGE:
+    case TYPE_CODE_STRING:
+    case TYPE_CODE_BITSTRING:
+    case TYPE_CODE_ERROR:
+    case TYPE_CODE_MEMBER:
+    case TYPE_CODE_METHOD:
+    case TYPE_CODE_COMPLEX:
+    default:
+      break;
+    }
+
+  return value_cast (type, arg);
+}
+
+/* Determine a function's address and its return type from its value.
+   Calls error() if the function is not valid for calling.  */
+
+static CORE_ADDR
+find_function_addr (struct value *function, struct type **retval_type)
+{
+  register struct type *ftype = check_typedef (VALUE_TYPE (function));
+  register enum type_code code = TYPE_CODE (ftype);
+  struct type *value_type;
+  CORE_ADDR funaddr;
+
+  /* If it's a member function, just look at the function
+     part of it.  */
+
+  /* Determine address to call.  */
+  if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
+    {
+      funaddr = VALUE_ADDRESS (function);
+      value_type = TYPE_TARGET_TYPE (ftype);
+    }
+  else if (code == TYPE_CODE_PTR)
+    {
+      funaddr = value_as_address (function);
+      ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
+      if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
+	  || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+	{
+	  funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
+	  value_type = TYPE_TARGET_TYPE (ftype);
+	}
+      else
+	value_type = builtin_type_int;
+    }
+  else if (code == TYPE_CODE_INT)
+    {
+      /* Handle the case of functions lacking debugging info.
+         Their values are characters since their addresses are char */
+      if (TYPE_LENGTH (ftype) == 1)
+	funaddr = value_as_address (value_addr (function));
+      else
+	/* Handle integer used as address of a function.  */
+	funaddr = (CORE_ADDR) value_as_long (function);
+
+      value_type = builtin_type_int;
+    }
+  else
+    error ("Invalid data type for function to be called.");
+
+  *retval_type = value_type;
+  return funaddr;
+}
+
+/* All this stuff with a dummy frame may seem unnecessarily complicated
+   (why not just save registers in GDB?).  The purpose of pushing a dummy
+   frame which looks just like a real frame is so that if you call a
+   function and then hit a breakpoint (get a signal, etc), "backtrace"
+   will look right.  Whether the backtrace needs to actually show the
+   stack at the time the inferior function was called is debatable, but
+   it certainly needs to not display garbage.  So if you are contemplating
+   making dummy frames be different from normal frames, consider that.  */
+
+/* Perform a function call in the inferior.
+   ARGS is a vector of values of arguments (NARGS of them).
+   FUNCTION is a value, the function to be called.
+   Returns a value representing what the function returned.
+   May fail to return, if a breakpoint or signal is hit
+   during the execution of the function.
+
+   ARGS is modified to contain coerced values. */
+
+static struct value *
+hand_function_call (struct value *function, int nargs, struct value **args)
+{
+  register CORE_ADDR sp;
+  register int i;
+  int rc;
+  CORE_ADDR start_sp;
+  /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
+     is in host byte order.  Before calling FIX_CALL_DUMMY, we byteswap it
+     and remove any extra bytes which might exist because ULONGEST is
+     bigger than REGISTER_SIZE.
+
+     NOTE: This is pretty wierd, as the call dummy is actually a
+     sequence of instructions.  But CISC machines will have
+     to pack the instructions into REGISTER_SIZE units (and
+     so will RISC machines for which INSTRUCTION_SIZE is not
+     REGISTER_SIZE).
+
+     NOTE: This is pretty stupid.  CALL_DUMMY should be in strict
+     target byte order. */
+
+  static ULONGEST *dummy;
+  int sizeof_dummy1;
+  char *dummy1;
+  CORE_ADDR old_sp;
+  struct type *value_type;
+  unsigned char struct_return;
+  CORE_ADDR struct_addr = 0;
+  struct regcache *retbuf;
+  struct cleanup *retbuf_cleanup;
+  struct inferior_status *inf_status;
+  struct cleanup *inf_status_cleanup;
+  CORE_ADDR funaddr;
+  int using_gcc;		/* Set to version of gcc in use, or zero if not gcc */
+  CORE_ADDR real_pc;
+  struct type *param_type = NULL;
+  struct type *ftype = check_typedef (SYMBOL_TYPE (function));
+  int n_method_args = 0;
+
+  dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
+  sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST);
+  dummy1 = alloca (sizeof_dummy1);
+  memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS);
+
+  if (!target_has_execution)
+    noprocess ();
+
+  /* Create a cleanup chain that contains the retbuf (buffer
+     containing the register values).  This chain is create BEFORE the
+     inf_status chain so that the inferior status can cleaned up
+     (restored or discarded) without having the retbuf freed.  */
+  retbuf = regcache_xmalloc (current_gdbarch);
+  retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
+
+  /* A cleanup for the inferior status.  Create this AFTER the retbuf
+     so that this can be discarded or applied without interfering with
+     the regbuf.  */
+  inf_status = save_inferior_status (1);
+  inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
+
+  /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
+     (and POP_FRAME for restoring them).  (At least on most machines)
+     they are saved on the stack in the inferior.  */
+  PUSH_DUMMY_FRAME;
+
+  old_sp = read_sp ();
+
+  /* Ensure that the initial SP is correctly aligned.  */
+  if (gdbarch_frame_align_p (current_gdbarch))
+    {
+      /* NOTE: cagney/2002-09-18:
+
+	 On a RISC architecture, a void parameterless generic dummy
+	 frame (i.e., no parameters, no result) typically does not
+	 need to push anything the stack and hence can leave SP and
+	 FP.  Similarly, a framelss (possibly leaf) function does not
+	 push anything on the stack and, hence, that too can leave FP
+	 and SP unchanged.  As a consequence, a sequence of void
+	 parameterless generic dummy frame calls to frameless
+	 functions will create a sequence of effectively identical
+	 frames (SP, FP and TOS and PC the same).  This, not
+	 suprisingly, results in what appears to be a stack in an
+	 infinite loop --- when GDB tries to find a generic dummy
+	 frame on the internal dummy frame stack, it will always find
+	 the first one.
+
+	 To avoid this problem, the code below always grows the stack.
+	 That way, two dummy frames can never be identical.  It does
+	 burn a few bytes of stack but that is a small price to pay
+	 :-).  */
+      sp = gdbarch_frame_align (current_gdbarch, old_sp);
+      if (sp == old_sp)
+	{
+	  if (INNER_THAN (1, 2))
+	    /* Stack grows down.  */
+	    sp = gdbarch_frame_align (current_gdbarch, old_sp - 1);
+	  else
+	    /* Stack grows up.  */
+	    sp = gdbarch_frame_align (current_gdbarch, old_sp + 1);
+	}
+      gdb_assert ((INNER_THAN (1, 2) && sp <= old_sp)
+		  || (INNER_THAN (2, 1) && sp >= old_sp));
+    }
+  else
+    /* FIXME: cagney/2002-09-18: Hey, you loose!  Who knows how badly
+       aligned the SP is!  Further, per comment above, if the generic
+       dummy frame ends up empty (because nothing is pushed) GDB won't
+       be able to correctly perform back traces.  If a target is
+       having trouble with backtraces, first thing to do is add
+       FRAME_ALIGN() to its architecture vector.  After that, try
+       adding SAVE_DUMMY_FRAME_TOS() and modifying FRAME_CHAIN so that
+       when the next outer frame is a generic dummy, it returns the
+       current frame's base.  */
+    sp = old_sp;
+
+  if (INNER_THAN (1, 2))
+    {
+      /* Stack grows down */
+      sp -= sizeof_dummy1;
+      start_sp = sp;
+    }
+  else
+    {
+      /* Stack grows up */
+      start_sp = sp;
+      sp += sizeof_dummy1;
+    }
+
+  /* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack
+     after allocating space for the call dummy.  A target can specify
+     a SIZEOF_DUMMY1 (via SIZEOF_CALL_DUMMY_WORDS) such that all local
+     alignment requirements are met.  */
+
+  funaddr = find_function_addr (function, &value_type);
+  CHECK_TYPEDEF (value_type);
+
+  {
+    struct block *b = block_for_pc (funaddr);
+    /* If compiled without -g, assume GCC 2.  */
+    using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
+  }
+
+  /* Are we returning a value using a structure return or a normal
+     value return? */
+
+  struct_return = using_struct_return (function, funaddr, value_type,
+				       using_gcc);
+
+  /* Create a call sequence customized for this function
+     and the number of arguments for it.  */
+  for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); i++)
+    store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
+			    REGISTER_SIZE,
+			    (ULONGEST) dummy[i]);
+
+#ifdef GDB_TARGET_IS_HPPA
+  real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
+			    value_type, using_gcc);
+#else
+  FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
+		  value_type, using_gcc);
+  real_pc = start_sp;
+#endif
+
+  if (CALL_DUMMY_LOCATION == ON_STACK)
+    {
+      write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
+      if (USE_GENERIC_DUMMY_FRAMES)
+	generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1);
+    }
+
+  if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END)
+    {
+      /* Convex Unix prohibits executing in the stack segment. */
+      /* Hope there is empty room at the top of the text segment. */
+      extern CORE_ADDR text_end;
+      static int checked = 0;
+      if (!checked)
+	for (start_sp = text_end - sizeof_dummy1; start_sp < text_end; ++start_sp)
+	  if (read_memory_integer (start_sp, 1) != 0)
+	    error ("text segment full -- no place to put call");
+      checked = 1;
+      sp = old_sp;
+      real_pc = text_end - sizeof_dummy1;
+      write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
+      if (USE_GENERIC_DUMMY_FRAMES)
+	generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1);
+    }
+
+  if (CALL_DUMMY_LOCATION == AFTER_TEXT_END)
+    {
+      extern CORE_ADDR text_end;
+      int errcode;
+      sp = old_sp;
+      real_pc = text_end;
+      errcode = target_write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
+      if (errcode != 0)
+	error ("Cannot write text segment -- call_function failed");
+      if (USE_GENERIC_DUMMY_FRAMES)
+	generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1);
+    }
+
+  if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
+    {
+      real_pc = funaddr;
+      if (USE_GENERIC_DUMMY_FRAMES)
+	/* NOTE: cagney/2002-04-13: The entry point is going to be
+           modified with a single breakpoint.  */
+	generic_save_call_dummy_addr (CALL_DUMMY_ADDRESS (),
+				      CALL_DUMMY_ADDRESS () + 1);
+    }
+
+#ifdef lint
+  sp = old_sp;			/* It really is used, for some ifdef's... */
+#endif
+
+  if (nargs < TYPE_NFIELDS (ftype))
+    error ("too few arguments in function call");
+
+  for (i = nargs - 1; i >= 0; i--)
+    {
+      int prototyped;
+
+      /* FIXME drow/2002-05-31: Should just always mark methods as
+	 prototyped.  Can we respect TYPE_VARARGS?  Probably not.  */
+      if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+	prototyped = 1;
+      else
+	prototyped = TYPE_PROTOTYPED (ftype);
+
+      if (i < TYPE_NFIELDS (ftype))
+	args[i] = value_arg_coerce (args[i], TYPE_FIELD_TYPE (ftype, i),
+				    prototyped);
+      else
+	args[i] = value_arg_coerce (args[i], NULL, 0);
+
+      /*elz: this code is to handle the case in which the function to be called
+         has a pointer to function as parameter and the corresponding actual argument
+         is the address of a function and not a pointer to function variable.
+         In aCC compiled code, the calls through pointers to functions (in the body
+         of the function called by hand) are made via $$dyncall_external which
+         requires some registers setting, this is taken care of if we call
+         via a function pointer variable, but not via a function address.
+         In cc this is not a problem. */
+
+      if (using_gcc == 0)
+	if (param_type && TYPE_CODE (ftype) != TYPE_CODE_METHOD)
+	  /* if this parameter is a pointer to function */
+	  if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
+	    if (TYPE_CODE (TYPE_TARGET_TYPE (param_type)) == TYPE_CODE_FUNC)
+	      /* elz: FIXME here should go the test about the compiler used
+	         to compile the target. We want to issue the error
+	         message only if the compiler used was HP's aCC.
+	         If we used HP's cc, then there is no problem and no need
+	         to return at this point */
+	      if (using_gcc == 0)	/* && compiler == aCC */
+		/* go see if the actual parameter is a variable of type
+		   pointer to function or just a function */
+		if (args[i]->lval == not_lval)
+		  {
+		    char *arg_name;
+		    if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL))
+		      error ("\
+You cannot use function <%s> as argument. \n\
+You must use a pointer to function type variable. Command ignored.", arg_name);
+		  }
+    }
+
+  if (REG_STRUCT_HAS_ADDR_P ())
+    {
+      /* This is a machine like the sparc, where we may need to pass a
+	 pointer to the structure, not the structure itself.  */
+      for (i = nargs - 1; i >= 0; i--)
+	{
+	  struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
+	  if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
+	       || TYPE_CODE (arg_type) == TYPE_CODE_UNION
+	       || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
+	       || TYPE_CODE (arg_type) == TYPE_CODE_STRING
+	       || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
+	       || TYPE_CODE (arg_type) == TYPE_CODE_SET
+	       || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
+		   && TYPE_LENGTH (arg_type) > 8)
+	       )
+	      && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
+	    {
+	      CORE_ADDR addr;
+	      int len;		/*  = TYPE_LENGTH (arg_type); */
+	      int aligned_len;
+	      arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
+	      len = TYPE_LENGTH (arg_type);
+
+	      if (STACK_ALIGN_P ())
+		/* MVS 11/22/96: I think at least some of this
+		   stack_align code is really broken.  Better to let
+		   PUSH_ARGUMENTS adjust the stack in a target-defined
+		   manner.  */
+		aligned_len = STACK_ALIGN (len);
+	      else
+		aligned_len = len;
+	      if (INNER_THAN (1, 2))
+		{
+		  /* stack grows downward */
+		  sp -= aligned_len;
+		  /* ... so the address of the thing we push is the
+		     stack pointer after we push it.  */
+		  addr = sp;
+		}
+	      else
+		{
+		  /* The stack grows up, so the address of the thing
+		     we push is the stack pointer before we push it.  */
+		  addr = sp;
+		  sp += aligned_len;
+		}
+	      /* Push the structure.  */
+	      write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len);
+	      /* The value we're going to pass is the address of the
+		 thing we just pushed.  */
+	      /*args[i] = value_from_longest (lookup_pointer_type (value_type),
+		(LONGEST) addr); */
+	      args[i] = value_from_pointer (lookup_pointer_type (arg_type),
+					    addr);
+	    }
+	}
+    }
+
+
+  /* Reserve space for the return structure to be written on the
+     stack, if necessary.  Make certain that the value is correctly
+     aligned. */
+
+  if (struct_return)
+    {
+      int len = TYPE_LENGTH (value_type);
+      if (STACK_ALIGN_P ())
+	/* MVS 11/22/96: I think at least some of this stack_align
+	   code is really broken.  Better to let PUSH_ARGUMENTS adjust
+	   the stack in a target-defined manner.  */
+	len = STACK_ALIGN (len);
+      if (INNER_THAN (1, 2))
+	{
+	  /* Stack grows downward.  Align STRUCT_ADDR and SP after
+             making space for the return value.  */
+	  sp -= len;
+	  if (gdbarch_frame_align_p (current_gdbarch))
+	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  struct_addr = sp;
+	}
+      else
+	{
+	  /* Stack grows upward.  Align the frame, allocate space, and
+             then again, re-align the frame??? */
+	  if (gdbarch_frame_align_p (current_gdbarch))
+	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  struct_addr = sp;
+	  sp += len;
+	  if (gdbarch_frame_align_p (current_gdbarch))
+	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	}
+    }
+
+  /* elz: on HPPA no need for this extra alignment, maybe it is needed
+     on other architectures. This is because all the alignment is
+     taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
+     in hppa_push_arguments */
+  if (EXTRA_STACK_ALIGNMENT_NEEDED)
+    {
+      /* MVS 11/22/96: I think at least some of this stack_align code
+	 is really broken.  Better to let PUSH_ARGUMENTS adjust the
+	 stack in a target-defined manner.  */
+      if (STACK_ALIGN_P () && INNER_THAN (1, 2))
+	{
+	  /* If stack grows down, we must leave a hole at the top. */
+	  int len = 0;
+
+	  for (i = nargs - 1; i >= 0; i--)
+	    len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
+	  if (CALL_DUMMY_STACK_ADJUST_P)
+	    len += CALL_DUMMY_STACK_ADJUST;
+	  sp -= STACK_ALIGN (len) - len;
+	}
+    }
+
+  sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr);
+
+  if (PUSH_RETURN_ADDRESS_P ())
+    /* for targets that use no CALL_DUMMY */
+    /* There are a number of targets now which actually don't write
+       any CALL_DUMMY instructions into the target, but instead just
+       save the machine state, push the arguments, and jump directly
+       to the callee function.  Since this doesn't actually involve
+       executing a JSR/BSR instruction, the return address must be set
+       up by hand, either by pushing onto the stack or copying into a
+       return-address register as appropriate.  Formerly this has been
+       done in PUSH_ARGUMENTS, but that's overloading its
+       functionality a bit, so I'm making it explicit to do it here.  */
+    sp = PUSH_RETURN_ADDRESS (real_pc, sp);
+
+  if (STACK_ALIGN_P () && !INNER_THAN (1, 2))
+    {
+      /* If stack grows up, we must leave a hole at the bottom, note
+         that sp already has been advanced for the arguments!  */
+      if (CALL_DUMMY_STACK_ADJUST_P)
+	sp += CALL_DUMMY_STACK_ADJUST;
+      sp = STACK_ALIGN (sp);
+    }
+
+/* XXX This seems wrong.  For stacks that grow down we shouldn't do
+   anything here!  */
+  /* MVS 11/22/96: I think at least some of this stack_align code is
+     really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
+     a target-defined manner.  */
+  if (CALL_DUMMY_STACK_ADJUST_P)
+    if (INNER_THAN (1, 2))
+      {
+	/* stack grows downward */
+	sp -= CALL_DUMMY_STACK_ADJUST;
+      }
+
+  /* Store the address at which the structure is supposed to be
+     written.  Note that this (and the code which reserved the space
+     above) assumes that gcc was used to compile this function.  Since
+     it doesn't cost us anything but space and if the function is pcc
+     it will ignore this value, we will make that assumption.
+
+     Also note that on some machines (like the sparc) pcc uses a
+     convention like gcc's.  */
+
+  if (struct_return)
+    STORE_STRUCT_RETURN (struct_addr, sp);
+
+  /* Write the stack pointer.  This is here because the statements above
+     might fool with it.  On SPARC, this write also stores the register
+     window into the right place in the new stack frame, which otherwise
+     wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
+  write_sp (sp);
+
+  if (SAVE_DUMMY_FRAME_TOS_P ())
+    SAVE_DUMMY_FRAME_TOS (sp);
+
+  {
+    char *name;
+    struct symbol *symbol;
+
+    name = NULL;
+    symbol = find_pc_function (funaddr);
+    if (symbol)
+      {
+	name = SYMBOL_SOURCE_NAME (symbol);
+      }
+    else
+      {
+	/* Try the minimal symbols.  */
+	struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
+
+	if (msymbol)
+	  {
+	    name = SYMBOL_SOURCE_NAME (msymbol);
+	  }
+      }
+    if (name == NULL)
+      {
+	char format[80];
+	sprintf (format, "at %s", local_hex_format ());
+	name = alloca (80);
+	/* FIXME-32x64: assumes funaddr fits in a long.  */
+	sprintf (name, format, (unsigned long) funaddr);
+      }
+
+    /* Execute the stack dummy routine, calling FUNCTION.
+       When it is done, discard the empty frame
+       after storing the contents of all regs into retbuf.  */
+    rc = run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf);
+
+    if (rc == 1)
+      {
+	/* We stopped inside the FUNCTION because of a random signal.
+	   Further execution of the FUNCTION is not allowed. */
+
+        if (unwind_on_signal_p)
+	  {
+	    /* The user wants the context restored. */
+
+            /* We must get back to the frame we were before the dummy call. */
+            POP_FRAME;
+
+	    /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
+	       a C++ name with arguments and stuff.  */
+	    error ("\
+The program being debugged was signaled while in a function called from GDB.\n\
+GDB has restored the context to what it was before the call.\n\
+To change this behavior use \"set unwindonsignal off\"\n\
+Evaluation of the expression containing the function (%s) will be abandoned.",
+		   name);
+	  }
+	else
+	  {
+	    /* The user wants to stay in the frame where we stopped (default).*/
+
+	    /* If we restored the inferior status (via the cleanup),
+	       we would print a spurious error message (Unable to
+	       restore previously selected frame), would write the
+	       registers from the inf_status (which is wrong), and
+	       would do other wrong things.  */
+	    discard_cleanups (inf_status_cleanup);
+	    discard_inferior_status (inf_status);
+
+	    /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
+	       a C++ name with arguments and stuff.  */
+	    error ("\
+The program being debugged was signaled while in a function called from GDB.\n\
+GDB remains in the frame where the signal was received.\n\
+To change this behavior use \"set unwindonsignal on\"\n\
+Evaluation of the expression containing the function (%s) will be abandoned.",
+		   name);
+	  }
+      }
+
+    if (rc == 2)
+      {
+	/* We hit a breakpoint inside the FUNCTION. */
+
+	/* If we restored the inferior status (via the cleanup), we
+	   would print a spurious error message (Unable to restore
+	   previously selected frame), would write the registers from
+	   the inf_status (which is wrong), and would do other wrong
+	   things.  */
+	discard_cleanups (inf_status_cleanup);
+	discard_inferior_status (inf_status);
+
+	/* The following error message used to say "The expression
+	   which contained the function call has been discarded."  It
+	   is a hard concept to explain in a few words.  Ideally, GDB
+	   would be able to resume evaluation of the expression when
+	   the function finally is done executing.  Perhaps someday
+	   this will be implemented (it would not be easy).  */
+
+	/* FIXME: Insert a bunch of wrap_here; name can be very long if it's
+	   a C++ name with arguments and stuff.  */
+	error ("\
+The program being debugged stopped while in a function called from GDB.\n\
+When the function (%s) is done executing, GDB will silently\n\
+stop (instead of continuing to evaluate the expression containing\n\
+the function call).", name);
+      }
+
+    /* If we get here the called FUNCTION run to completion. */
+
+    /* Restore the inferior status, via its cleanup.  At this stage,
+       leave the RETBUF alone.  */
+    do_cleanups (inf_status_cleanup);
+
+    /* Figure out the value returned by the function.  */
+    /* elz: I defined this new macro for the hppa architecture only.
+       this gives us a way to get the value returned by the function
+       from the stack, at the same address we told the function to put
+       it.  We cannot assume on the pa that r28 still contains the
+       address of the returned structure. Usually this will be
+       overwritten by the callee.  I don't know about other
+       architectures, so I defined this macro */
+#ifdef VALUE_RETURNED_FROM_STACK
+    if (struct_return)
+      {
+	do_cleanups (retbuf_cleanup);
+	return VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
+      }
+#endif
+    /* NOTE: cagney/2002-09-10: Only when the stack has been correctly
+       aligned (using frame_align()) do we can trust STRUCT_ADDR and
+       fetch the return value direct from the stack.  This lack of
+       trust comes about because legacy targets have a nasty habit of
+       silently, and local to PUSH_ARGUMENTS(), moving STRUCT_ADDR.
+       For such targets, just hope that value_being_returned() can
+       find the adjusted value.  */
+    if (struct_return && gdbarch_frame_align_p (current_gdbarch))
+      {
+        struct value *retval = value_at (value_type, struct_addr, NULL);
+        do_cleanups (retbuf_cleanup);
+        return retval;
+      }
+    else
+      {
+	struct value *retval = value_being_returned (value_type, retbuf,
+						     struct_return);
+	do_cleanups (retbuf_cleanup);
+	return retval;
+      }
+  }
+}
+
+struct value *
+call_function_by_hand (struct value *function, int nargs, struct value **args)
+{
+  if (CALL_DUMMY_P)
+    {
+      return hand_function_call (function, nargs, args);
+    }
+  else
+    {
+      error ("Cannot invoke functions on this machine.");
+    }
+}
+
+
+
+/* Create a value for an array by allocating space in the inferior, copying
+   the data into that space, and then setting up an array value.
+
+   The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
+   populated from the values passed in ELEMVEC.
+
+   The element type of the array is inherited from the type of the
+   first element, and all elements must have the same size (though we
+   don't currently enforce any restriction on their types). */
+
+struct value *
+value_array (int lowbound, int highbound, struct value **elemvec)
+{
+  int nelem;
+  int idx;
+  unsigned int typelength;
+  struct value *val;
+  struct type *rangetype;
+  struct type *arraytype;
+  CORE_ADDR addr;
+
+  /* Validate that the bounds are reasonable and that each of the elements
+     have the same size. */
+
+  nelem = highbound - lowbound + 1;
+  if (nelem <= 0)
+    {
+      error ("bad array bounds (%d, %d)", lowbound, highbound);
+    }
+  typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
+  for (idx = 1; idx < nelem; idx++)
+    {
+      if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
+	{
+	  error ("array elements must all be the same size");
+	}
+    }
+
+  rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
+				 lowbound, highbound);
+  arraytype = create_array_type ((struct type *) NULL,
+			      VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
+
+  if (!current_language->c_style_arrays)
+    {
+      val = allocate_value (arraytype);
+      for (idx = 0; idx < nelem; idx++)
+	{
+	  memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
+		  VALUE_CONTENTS_ALL (elemvec[idx]),
+		  typelength);
+	}
+      VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
+      return val;
+    }
+
+  /* Allocate space to store the array in the inferior, and then initialize
+     it by copying in each element.  FIXME:  Is it worth it to create a
+     local buffer in which to collect each value and then write all the
+     bytes in one operation? */
+
+  addr = allocate_space_in_inferior (nelem * typelength);
+  for (idx = 0; idx < nelem; idx++)
+    {
+      write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
+		    typelength);
+    }
+
+  /* Create the array type and set up an array value to be evaluated lazily. */
+
+  val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
+  return (val);
+}
+
+/* Create a value for a string constant by allocating space in the inferior,
+   copying the data into that space, and returning the address with type
+   TYPE_CODE_STRING.  PTR points to the string constant data; LEN is number
+   of characters.
+   Note that string types are like array of char types with a lower bound of
+   zero and an upper bound of LEN - 1.  Also note that the string may contain
+   embedded null bytes. */
+
+struct value *
+value_string (char *ptr, int len)
+{
+  struct value *val;
+  int lowbound = current_language->string_lower_bound;
+  struct type *rangetype = create_range_type ((struct type *) NULL,
+					      builtin_type_int,
+					      lowbound, len + lowbound - 1);
+  struct type *stringtype
+  = create_string_type ((struct type *) NULL, rangetype);
+  CORE_ADDR addr;
+
+  if (current_language->c_style_arrays == 0)
+    {
+      val = allocate_value (stringtype);
+      memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
+      return val;
+    }
+
+
+  /* Allocate space to store the string in the inferior, and then
+     copy LEN bytes from PTR in gdb to that address in the inferior. */
+
+  addr = allocate_space_in_inferior (len);
+  write_memory (addr, ptr, len);
+
+  val = value_at_lazy (stringtype, addr, NULL);
+  return (val);
+}
+
+struct value *
+value_bitstring (char *ptr, int len)
+{
+  struct value *val;
+  struct type *domain_type = create_range_type (NULL, builtin_type_int,
+						0, len - 1);
+  struct type *type = create_set_type ((struct type *) NULL, domain_type);
+  TYPE_CODE (type) = TYPE_CODE_BITSTRING;
+  val = allocate_value (type);
+  memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
+  return val;
+}
+
+/* See if we can pass arguments in T2 to a function which takes arguments
+   of types T1.  T1 is a list of NARGS arguments, and T2 is a NULL-terminated
+   vector.  If some arguments need coercion of some sort, then the coerced
+   values are written into T2.  Return value is 0 if the arguments could be
+   matched, or the position at which they differ if not.
+
+   STATICP is nonzero if the T1 argument list came from a
+   static member function.  T2 will still include the ``this'' pointer,
+   but it will be skipped.
+
+   For non-static member functions, we ignore the first argument,
+   which is the type of the instance variable.  This is because we want
+   to handle calls with objects from derived classes.  This is not
+   entirely correct: we should actually check to make sure that a
+   requested operation is type secure, shouldn't we?  FIXME.  */
+
+static int
+typecmp (int staticp, int varargs, int nargs,
+	 struct field t1[], struct value *t2[])
+{
+  int i;
+
+  if (t2 == 0)
+    internal_error (__FILE__, __LINE__, "typecmp: no argument list");
+
+  /* Skip ``this'' argument if applicable.  T2 will always include THIS.  */
+  if (staticp)
+    t2 ++;
+
+  for (i = 0;
+       (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
+       i++)
+    {
+      struct type *tt1, *tt2;
+
+      if (!t2[i])
+	return i + 1;
+
+      tt1 = check_typedef (t1[i].type);
+      tt2 = check_typedef (VALUE_TYPE (t2[i]));
+
+      if (TYPE_CODE (tt1) == TYPE_CODE_REF
+      /* We should be doing hairy argument matching, as below.  */
+	  && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
+	{
+	  if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
+	    t2[i] = value_coerce_array (t2[i]);
+	  else
+	    t2[i] = value_addr (t2[i]);
+	  continue;
+	}
+
+      /* djb - 20000715 - Until the new type structure is in the
+	 place, and we can attempt things like implicit conversions,
+	 we need to do this so you can take something like a map<const
+	 char *>, and properly access map["hello"], because the
+	 argument to [] will be a reference to a pointer to a char,
+	 and the argument will be a pointer to a char. */
+      while ( TYPE_CODE(tt1) == TYPE_CODE_REF ||
+	      TYPE_CODE (tt1) == TYPE_CODE_PTR)
+	{
+	  tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
+	}
+      while ( TYPE_CODE(tt2) == TYPE_CODE_ARRAY ||
+	      TYPE_CODE(tt2) == TYPE_CODE_PTR ||
+	      TYPE_CODE(tt2) == TYPE_CODE_REF)
+	{
+	  tt2 = check_typedef( TYPE_TARGET_TYPE(tt2) );
+	}
+      if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
+	continue;
+      /* Array to pointer is a `trivial conversion' according to the ARM.  */
+
+      /* We should be doing much hairier argument matching (see section 13.2
+         of the ARM), but as a quick kludge, just check for the same type
+         code.  */
+      if (TYPE_CODE (t1[i].type) != TYPE_CODE (VALUE_TYPE (t2[i])))
+	return i + 1;
+    }
+  if (varargs || t2[i] == NULL)
+    return 0;
+  return i + 1;
+}
+
+/* Helper function used by value_struct_elt to recurse through baseclasses.
+   Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
+   and search in it assuming it has (class) type TYPE.
+   If found, return value, else return NULL.
+
+   If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
+   look for a baseclass named NAME.  */
+
+static struct value *
+search_struct_field (char *name, struct value *arg1, int offset,
+		     register struct type *type, int looking_for_baseclass)
+{
+  int i;
+  int nbases = TYPE_N_BASECLASSES (type);
+
+  CHECK_TYPEDEF (type);
+
+  if (!looking_for_baseclass)
+    for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
+      {
+	char *t_field_name = TYPE_FIELD_NAME (type, i);
+
+	if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
+	  {
+	    struct value *v;
+	    if (TYPE_FIELD_STATIC (type, i))
+	      {
+		v = value_static_field (type, i);
+		if (v == 0)
+		  error ("field %s is nonexistent or has been optimised out",
+			 name);
+	      }
+	    else
+	      {
+		v = value_primitive_field (arg1, offset, i, type);
+		if (v == 0)
+		  error ("there is no field named %s", name);
+	      }
+	    return v;
+	  }
+
+	if (t_field_name
+	    && (t_field_name[0] == '\0'
+		|| (TYPE_CODE (type) == TYPE_CODE_UNION
+		    && (strcmp_iw (t_field_name, "else") == 0))))
+	  {
+	    struct type *field_type = TYPE_FIELD_TYPE (type, i);
+	    if (TYPE_CODE (field_type) == TYPE_CODE_UNION
+		|| TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
+	      {
+		/* Look for a match through the fields of an anonymous union,
+		   or anonymous struct.  C++ provides anonymous unions.
+
+		   In the GNU Chill (OBSOLETE) implementation of
+		   variant record types, each <alternative field> has
+		   an (anonymous) union type, each member of the union
+		   represents a <variant alternative>.  Each <variant
+		   alternative> is represented as a struct, with a
+		   member for each <variant field>.  */
+
+		struct value *v;
+		int new_offset = offset;
+
+		/* This is pretty gross.  In G++, the offset in an
+		   anonymous union is relative to the beginning of the
+		   enclosing struct.  In the GNU Chill (OBSOLETE)
+		   implementation of variant records, the bitpos is
+		   zero in an anonymous union field, so we have to add
+		   the offset of the union here. */
+		if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
+		    || (TYPE_NFIELDS (field_type) > 0
+			&& TYPE_FIELD_BITPOS (field_type, 0) == 0))
+		  new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
+
+		v = search_struct_field (name, arg1, new_offset, field_type,
+					 looking_for_baseclass);
+		if (v)
+		  return v;
+	      }
+	  }
+      }
+
+  for (i = 0; i < nbases; i++)
+    {
+      struct value *v;
+      struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
+      /* If we are looking for baseclasses, this is what we get when we
+         hit them.  But it could happen that the base part's member name
+         is not yet filled in.  */
+      int found_baseclass = (looking_for_baseclass
+			     && TYPE_BASECLASS_NAME (type, i) != NULL
+			     && (strcmp_iw (name, TYPE_BASECLASS_NAME (type, i)) == 0));
+
+      if (BASETYPE_VIA_VIRTUAL (type, i))
+	{
+	  int boffset;
+	  struct value *v2 = allocate_value (basetype);
+
+	  boffset = baseclass_offset (type, i,
+				      VALUE_CONTENTS (arg1) + offset,
+				      VALUE_ADDRESS (arg1)
+				      + VALUE_OFFSET (arg1) + offset);
+	  if (boffset == -1)
+	    error ("virtual baseclass botch");
+
+	  /* The virtual base class pointer might have been clobbered by the
+	     user program. Make sure that it still points to a valid memory
+	     location.  */
+
+	  boffset += offset;
+	  if (boffset < 0 || boffset >= TYPE_LENGTH (type))
+	    {
+	      CORE_ADDR base_addr;
+
+	      base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
+	      if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
+				      TYPE_LENGTH (basetype)) != 0)
+		error ("virtual baseclass botch");
+	      VALUE_LVAL (v2) = lval_memory;
+	      VALUE_ADDRESS (v2) = base_addr;
+	    }
+	  else
+	    {
+	      VALUE_LVAL (v2) = VALUE_LVAL (arg1);
+	      VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
+	      VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
+	      if (VALUE_LAZY (arg1))
+		VALUE_LAZY (v2) = 1;
+	      else
+		memcpy (VALUE_CONTENTS_RAW (v2),
+			VALUE_CONTENTS_RAW (arg1) + boffset,
+			TYPE_LENGTH (basetype));
+	    }
+
+	  if (found_baseclass)
+	    return v2;
+	  v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
+				   looking_for_baseclass);
+	}
+      else if (found_baseclass)
+	v = value_primitive_field (arg1, offset, i, type);
+      else
+	v = search_struct_field (name, arg1,
+			       offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
+				 basetype, looking_for_baseclass);
+      if (v)
+	return v;
+    }
+  return NULL;
+}
+
+
+/* Return the offset (in bytes) of the virtual base of type BASETYPE
+ * in an object pointed to by VALADDR (on the host), assumed to be of
+ * type TYPE.  OFFSET is number of bytes beyond start of ARG to start
+ * looking (in case VALADDR is the contents of an enclosing object).
+ *
+ * This routine recurses on the primary base of the derived class because
+ * the virtual base entries of the primary base appear before the other
+ * virtual base entries.
+ *
+ * If the virtual base is not found, a negative integer is returned.
+ * The magnitude of the negative integer is the number of entries in
+ * the virtual table to skip over (entries corresponding to various
+ * ancestral classes in the chain of primary bases).
+ *
+ * Important: This assumes the HP / Taligent C++ runtime
+ * conventions. Use baseclass_offset() instead to deal with g++
+ * conventions.  */
+
+void
+find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
+		      int offset, int *boffset_p, int *skip_p)
+{
+  int boffset;			/* offset of virtual base */
+  int index;			/* displacement to use in virtual table */
+  int skip;
+
+  struct value *vp;
+  CORE_ADDR vtbl;		/* the virtual table pointer */
+  struct type *pbc;		/* the primary base class */
+
+  /* Look for the virtual base recursively in the primary base, first.
+   * This is because the derived class object and its primary base
+   * subobject share the primary virtual table.  */
+
+  boffset = 0;
+  pbc = TYPE_PRIMARY_BASE (type);
+  if (pbc)
+    {
+      find_rt_vbase_offset (pbc, basetype, valaddr, offset, &boffset, &skip);
+      if (skip < 0)
+	{
+	  *boffset_p = boffset;
+	  *skip_p = -1;
+	  return;
+	}
+    }
+  else
+    skip = 0;
+
+
+  /* Find the index of the virtual base according to HP/Taligent
+     runtime spec. (Depth-first, left-to-right.)  */
+  index = virtual_base_index_skip_primaries (basetype, type);
+
+  if (index < 0)
+    {
+      *skip_p = skip + virtual_base_list_length_skip_primaries (type);
+      *boffset_p = 0;
+      return;
+    }
+
+  /* pai: FIXME -- 32x64 possible problem */
+  /* First word (4 bytes) in object layout is the vtable pointer */
+  vtbl = *(CORE_ADDR *) (valaddr + offset);
+
+  /* Before the constructor is invoked, things are usually zero'd out. */
+  if (vtbl == 0)
+    error ("Couldn't find virtual table -- object may not be constructed yet.");
+
+
+  /* Find virtual base's offset -- jump over entries for primary base
+   * ancestors, then use the index computed above.  But also adjust by
+   * HP_ACC_VBASE_START for the vtable slots before the start of the
+   * virtual base entries.  Offset is negative -- virtual base entries
+   * appear _before_ the address point of the virtual table. */
+
+  /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
+     & use long type */
+
+  /* epstein : FIXME -- added param for overlay section. May not be correct */
+  vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START), NULL);
+  boffset = value_as_long (vp);
+  *skip_p = -1;
+  *boffset_p = boffset;
+  return;
+}
+
+
+/* Helper function used by value_struct_elt to recurse through baseclasses.
+   Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
+   and search in it assuming it has (class) type TYPE.
+   If found, return value, else if name matched and args not return (value)-1,
+   else return NULL. */
+
+static struct value *
+search_struct_method (char *name, struct value **arg1p,
+		      struct value **args, int offset,
+		      int *static_memfuncp, register struct type *type)
+{
+  int i;
+  struct value *v;
+  int name_matched = 0;
+  char dem_opname[64];
+
+  CHECK_TYPEDEF (type);
+  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
+    {
+      char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
+      /* FIXME!  May need to check for ARM demangling here */
+      if (strncmp (t_field_name, "__", 2) == 0 ||
+	  strncmp (t_field_name, "op", 2) == 0 ||
+	  strncmp (t_field_name, "type", 4) == 0)
+	{
+	  if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
+	    t_field_name = dem_opname;
+	  else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
+	    t_field_name = dem_opname;
+	}
+      if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
+	{
+	  int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
+	  struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
+	  name_matched = 1;
+
+	  check_stub_method_group (type, i);
+	  if (j > 0 && args == 0)
+	    error ("cannot resolve overloaded method `%s': no arguments supplied", name);
+	  else if (j == 0 && args == 0)
+	    {
+	      v = value_fn_field (arg1p, f, j, type, offset);
+	      if (v != NULL)
+		return v;
+	    }
+	  else
+	    while (j >= 0)
+	      {
+		if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
+			      TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
+			      TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
+			      TYPE_FN_FIELD_ARGS (f, j), args))
+		  {
+		    if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
+		      return value_virtual_fn_field (arg1p, f, j, type, offset);
+		    if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
+		      *static_memfuncp = 1;
+		    v = value_fn_field (arg1p, f, j, type, offset);
+		    if (v != NULL)
+		      return v;       
+		  }
+		j--;
+	      }
+	}
+    }
+
+  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
+    {
+      int base_offset;
+
+      if (BASETYPE_VIA_VIRTUAL (type, i))
+	{
+	  if (TYPE_HAS_VTABLE (type))
+	    {
+	      /* HP aCC compiled type, search for virtual base offset
+	         according to HP/Taligent runtime spec.  */
+	      int skip;
+	      find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
+				    VALUE_CONTENTS_ALL (*arg1p),
+				    offset + VALUE_EMBEDDED_OFFSET (*arg1p),
+				    &base_offset, &skip);
+	      if (skip >= 0)
+		error ("Virtual base class offset not found in vtable");
+	    }
+	  else
+	    {
+	      struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
+	      char *base_valaddr;
+
+	      /* The virtual base class pointer might have been clobbered by the
+	         user program. Make sure that it still points to a valid memory
+	         location.  */
+
+	      if (offset < 0 || offset >= TYPE_LENGTH (type))
+		{
+		  base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
+		  if (target_read_memory (VALUE_ADDRESS (*arg1p)
+					  + VALUE_OFFSET (*arg1p) + offset,
+					  base_valaddr,
+					  TYPE_LENGTH (baseclass)) != 0)
+		    error ("virtual baseclass botch");
+		}
+	      else
+		base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
+
+	      base_offset =
+		baseclass_offset (type, i, base_valaddr,
+				  VALUE_ADDRESS (*arg1p)
+				  + VALUE_OFFSET (*arg1p) + offset);
+	      if (base_offset == -1)
+		error ("virtual baseclass botch");
+	    }
+	}
+      else
+	{
+	  base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
+	}
+      v = search_struct_method (name, arg1p, args, base_offset + offset,
+				static_memfuncp, TYPE_BASECLASS (type, i));
+      if (v == (struct value *) - 1)
+	{
+	  name_matched = 1;
+	}
+      else if (v)
+	{
+/* FIXME-bothner:  Why is this commented out?  Why is it here?  */
+/*        *arg1p = arg1_tmp; */
+	  return v;
+	}
+    }
+  if (name_matched)
+    return (struct value *) - 1;
+  else
+    return NULL;
+}
+
+/* Given *ARGP, a value of type (pointer to a)* structure/union,
+   extract the component named NAME from the ultimate target structure/union
+   and return it as a value with its appropriate type.
+   ERR is used in the error message if *ARGP's type is wrong.
+
+   C++: ARGS is a list of argument types to aid in the selection of
+   an appropriate method. Also, handle derived types.
+
+   STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
+   where the truthvalue of whether the function that was resolved was
+   a static member function or not is stored.
+
+   ERR is an error message to be printed in case the field is not found.  */
+
+struct value *
+value_struct_elt (struct value **argp, struct value **args,
+		  char *name, int *static_memfuncp, char *err)
+{
+  register struct type *t;
+  struct value *v;
+
+  COERCE_ARRAY (*argp);
+
+  t = check_typedef (VALUE_TYPE (*argp));
+
+  /* Follow pointers until we get to a non-pointer.  */
+
+  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
+    {
+      *argp = value_ind (*argp);
+      /* Don't coerce fn pointer to fn and then back again!  */
+      if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
+	COERCE_ARRAY (*argp);
+      t = check_typedef (VALUE_TYPE (*argp));
+    }
+
+  if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
+    error ("not implemented: member type in value_struct_elt");
+
+  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
+      && TYPE_CODE (t) != TYPE_CODE_UNION)
+    error ("Attempt to extract a component of a value that is not a %s.", err);
+
+  /* Assume it's not, unless we see that it is.  */
+  if (static_memfuncp)
+    *static_memfuncp = 0;
+
+  if (!args)
+    {
+      /* if there are no arguments ...do this...  */
+
+      /* Try as a field first, because if we succeed, there
+         is less work to be done.  */
+      v = search_struct_field (name, *argp, 0, t, 0);
+      if (v)
+	return v;
+
+      /* C++: If it was not found as a data field, then try to
+         return it as a pointer to a method.  */
+
+      if (destructor_name_p (name, t))
+	error ("Cannot get value of destructor");
+
+      v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
+
+      if (v == (struct value *) - 1)
+	error ("Cannot take address of a method");
+      else if (v == 0)
+	{
+	  if (TYPE_NFN_FIELDS (t))
+	    error ("There is no member or method named %s.", name);
+	  else
+	    error ("There is no member named %s.", name);
+	}
+      return v;
+    }
+
+  if (destructor_name_p (name, t))
+    {
+      if (!args[1])
+	{
+	  /* Destructors are a special case.  */
+	  int m_index, f_index;
+
+	  v = NULL;
+	  if (get_destructor_fn_field (t, &m_index, &f_index))
+	    {
+	      v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, m_index),
+				  f_index, NULL, 0);
+	    }
+	  if (v == NULL)
+	    error ("could not find destructor function named %s.", name);
+	  else
+	    return v;
+	}
+      else
+	{
+	  error ("destructor should not have any argument");
+	}
+    }
+  else
+    v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
+  
+  if (v == (struct value *) - 1)
+    {
+      error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name);
+    }
+  else if (v == 0)
+    {
+      /* See if user tried to invoke data as function.  If so,
+         hand it back.  If it's not callable (i.e., a pointer to function),
+         gdb should give an error.  */
+      v = search_struct_field (name, *argp, 0, t, 0);
+    }
+
+  if (!v)
+    error ("Structure has no component named %s.", name);
+  return v;
+}
+
+/* Search through the methods of an object (and its bases)
+ * to find a specified method. Return the pointer to the
+ * fn_field list of overloaded instances.
+ * Helper function for value_find_oload_list.
+ * ARGP is a pointer to a pointer to a value (the object)
+ * METHOD is a string containing the method name
+ * OFFSET is the offset within the value
+ * TYPE is the assumed type of the object
+ * NUM_FNS is the number of overloaded instances
+ * BASETYPE is set to the actual type of the subobject where the method is found
+ * BOFFSET is the offset of the base subobject where the method is found */
+
+static struct fn_field *
+find_method_list (struct value **argp, char *method, int offset,
+		  struct type *type, int *num_fns,
+		  struct type **basetype, int *boffset)
+{
+  int i;
+  struct fn_field *f;
+  CHECK_TYPEDEF (type);
+
+  *num_fns = 0;
+
+  /* First check in object itself */
+  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
+    {
+      /* pai: FIXME What about operators and type conversions? */
+      char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
+      if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
+	{
+	  int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
+	  struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
+
+	  *num_fns = len;
+	  *basetype = type;
+	  *boffset = offset;
+
+	  /* Resolve any stub methods.  */
+	  check_stub_method_group (type, i);
+
+	  return f;
+	}
+    }
+
+  /* Not found in object, check in base subobjects */
+  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
+    {
+      int base_offset;
+      if (BASETYPE_VIA_VIRTUAL (type, i))
+	{
+	  if (TYPE_HAS_VTABLE (type))
+	    {
+	      /* HP aCC compiled type, search for virtual base offset
+	       * according to HP/Taligent runtime spec.  */
+	      int skip;
+	      find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
+				    VALUE_CONTENTS_ALL (*argp),
+				    offset + VALUE_EMBEDDED_OFFSET (*argp),
+				    &base_offset, &skip);
+	      if (skip >= 0)
+		error ("Virtual base class offset not found in vtable");
+	    }
+	  else
+	    {
+	      /* probably g++ runtime model */
+	      base_offset = VALUE_OFFSET (*argp) + offset;
+	      base_offset =
+		baseclass_offset (type, i,
+				  VALUE_CONTENTS (*argp) + base_offset,
+				  VALUE_ADDRESS (*argp) + base_offset);
+	      if (base_offset == -1)
+		error ("virtual baseclass botch");
+	    }
+	}
+      else
+	/* non-virtual base, simply use bit position from debug info */
+	{
+	  base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
+	}
+      f = find_method_list (argp, method, base_offset + offset,
+			    TYPE_BASECLASS (type, i), num_fns, basetype,
+			    boffset);
+      if (f)
+	return f;
+    }
+  return NULL;
+}
+
+/* Return the list of overloaded methods of a specified name.
+ * ARGP is a pointer to a pointer to a value (the object)
+ * METHOD is the method name
+ * OFFSET is the offset within the value contents
+ * NUM_FNS is the number of overloaded instances
+ * BASETYPE is set to the type of the base subobject that defines the method
+ * BOFFSET is the offset of the base subobject which defines the method */
+
+struct fn_field *
+value_find_oload_method_list (struct value **argp, char *method, int offset,
+			      int *num_fns, struct type **basetype,
+			      int *boffset)
+{
+  struct type *t;
+
+  t = check_typedef (VALUE_TYPE (*argp));
+
+  /* code snarfed from value_struct_elt */
+  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
+    {
+      *argp = value_ind (*argp);
+      /* Don't coerce fn pointer to fn and then back again!  */
+      if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
+	COERCE_ARRAY (*argp);
+      t = check_typedef (VALUE_TYPE (*argp));
+    }
+
+  if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
+    error ("Not implemented: member type in value_find_oload_lis");
+
+  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
+      && TYPE_CODE (t) != TYPE_CODE_UNION)
+    error ("Attempt to extract a component of a value that is not a struct or union");
+
+  return find_method_list (argp, method, 0, t, num_fns, basetype, boffset);
+}
+
+/* Given an array of argument types (ARGTYPES) (which includes an
+   entry for "this" in the case of C++ methods), the number of
+   arguments NARGS, the NAME of a function whether it's a method or
+   not (METHOD), and the degree of laxness (LAX) in conforming to
+   overload resolution rules in ANSI C++, find the best function that
+   matches on the argument types according to the overload resolution
+   rules.
+
+   In the case of class methods, the parameter OBJ is an object value
+   in which to search for overloaded methods.
+
+   In the case of non-method functions, the parameter FSYM is a symbol
+   corresponding to one of the overloaded functions.
+
+   Return value is an integer: 0 -> good match, 10 -> debugger applied
+   non-standard coercions, 100 -> incompatible.
+
+   If a method is being searched for, VALP will hold the value.
+   If a non-method is being searched for, SYMP will hold the symbol for it.
+
+   If a method is being searched for, and it is a static method,
+   then STATICP will point to a non-zero value.
+
+   Note: This function does *not* check the value of
+   overload_resolution.  Caller must check it to see whether overload
+   resolution is permitted.
+ */
+
+int
+find_overload_match (struct type **arg_types, int nargs, char *name, int method,
+		     int lax, struct value **objp, struct symbol *fsym,
+		     struct value **valp, struct symbol **symp, int *staticp)
+{
+  int nparms;
+  struct type **parm_types;
+  int champ_nparms = 0;
+  struct value *obj = (objp ? *objp : NULL);
+
+  short oload_champ = -1;	/* Index of best overloaded function */
+  short oload_ambiguous = 0;	/* Current ambiguity state for overload resolution */
+  /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
+  short oload_ambig_champ = -1;	/* 2nd contender for best match */
+  short oload_non_standard = 0;	/* did we have to use non-standard conversions? */
+  short oload_incompatible = 0;	/* are args supplied incompatible with any function? */
+
+  struct badness_vector *bv;	/* A measure of how good an overloaded instance is */
+  struct badness_vector *oload_champ_bv = NULL;		/* The measure for the current best match */
+
+  struct value *temp = obj;
+  struct fn_field *fns_ptr = NULL;	/* For methods, the list of overloaded methods */
+  struct symbol **oload_syms = NULL;	/* For non-methods, the list of overloaded function symbols */
+  int num_fns = 0;		/* Number of overloaded instances being considered */
+  struct type *basetype = NULL;
+  int boffset;
+  register int jj;
+  register int ix;
+  int static_offset;
+  struct cleanup *cleanups = NULL;
+
+  char *obj_type_name = NULL;
+  char *func_name = NULL;
+
+  /* Get the list of overloaded methods or functions */
+  if (method)
+    {
+      obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
+      /* Hack: evaluate_subexp_standard often passes in a pointer
+         value rather than the object itself, so try again */
+      if ((!obj_type_name || !*obj_type_name) &&
+	  (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
+	obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
+
+      fns_ptr = value_find_oload_method_list (&temp, name, 0,
+					      &num_fns,
+					      &basetype, &boffset);
+      if (!fns_ptr || !num_fns)
+	error ("Couldn't find method %s%s%s",
+	       obj_type_name,
+	       (obj_type_name && *obj_type_name) ? "::" : "",
+	       name);
+      /* If we are dealing with stub method types, they should have
+	 been resolved by find_method_list via value_find_oload_method_list
+	 above.  */
+      gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
+    }
+  else
+    {
+      int i = -1;
+      func_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_NO_OPTS);
+
+      /* If the name is NULL this must be a C-style function.
+         Just return the same symbol. */
+      if (!func_name)
+        {
+	  *symp = fsym;
+          return 0;
+        }
+
+      oload_syms = make_symbol_overload_list (fsym);
+      cleanups = make_cleanup (xfree, oload_syms);
+      while (oload_syms[++i])
+	num_fns++;
+      if (!num_fns)
+	error ("Couldn't find function %s", func_name);
+    }
+
+  oload_champ_bv = NULL;
+
+  /* Consider each candidate in turn */
+  for (ix = 0; ix < num_fns; ix++)
+    {
+      static_offset = 0;
+      if (method)
+	{
+	  if (TYPE_FN_FIELD_STATIC_P (fns_ptr, ix))
+	    static_offset = 1;
+	  nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
+	}
+      else
+	{
+	  /* If it's not a method, this is the proper place */
+	  nparms=TYPE_NFIELDS(SYMBOL_TYPE(oload_syms[ix]));
+	}
+
+      /* Prepare array of parameter types */
+      parm_types = (struct type **) xmalloc (nparms * (sizeof (struct type *)));
+      for (jj = 0; jj < nparms; jj++)
+	parm_types[jj] = (method
+			  ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
+			  : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj));
+
+      /* Compare parameter types to supplied argument types.  Skip THIS for
+         static methods.  */
+      bv = rank_function (parm_types, nparms, arg_types + static_offset,
+			  nargs - static_offset);
+
+      if (!oload_champ_bv)
+	{
+	  oload_champ_bv = bv;
+	  oload_champ = 0;
+	  champ_nparms = nparms;
+	}
+      else
+	/* See whether current candidate is better or worse than previous best */
+	switch (compare_badness (bv, oload_champ_bv))
+	  {
+	  case 0:
+	    oload_ambiguous = 1;	/* top two contenders are equally good */
+	    oload_ambig_champ = ix;
+	    break;
+	  case 1:
+	    oload_ambiguous = 2;	/* incomparable top contenders */
+	    oload_ambig_champ = ix;
+	    break;
+	  case 2:
+	    oload_champ_bv = bv;	/* new champion, record details */
+	    oload_ambiguous = 0;
+	    oload_champ = ix;
+	    oload_ambig_champ = -1;
+	    champ_nparms = nparms;
+	    break;
+	  case 3:
+	  default:
+	    break;
+	  }
+      xfree (parm_types);
+      if (overload_debug)
+	{
+	  if (method)
+	    fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
+	  else
+	    fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
+	  for (jj = 0; jj < nargs - static_offset; jj++)
+	    fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
+	  fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
+	}
+    }				/* end loop over all candidates */
+  /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
+     if they have the exact same goodness. This is because there is no
+     way to differentiate based on return type, which we need to in
+     cases like overloads of .begin() <It's both const and non-const> */
+#if 0
+  if (oload_ambiguous)
+    {
+      if (method)
+	error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
+	       obj_type_name,
+	       (obj_type_name && *obj_type_name) ? "::" : "",
+	       name);
+      else
+	error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
+	       func_name);
+    }
+#endif
+
+  /* Check how bad the best match is.  */
+  static_offset = 0;
+  if (method && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ))
+    static_offset = 1;
+  for (ix = 1; ix <= nargs - static_offset; ix++)
+    {
+      if (oload_champ_bv->rank[ix] >= 100)
+	oload_incompatible = 1;	/* truly mismatched types */
+
+      else if (oload_champ_bv->rank[ix] >= 10)
+	oload_non_standard = 1;	/* non-standard type conversions needed */
+    }
+  if (oload_incompatible)
+    {
+      if (method)
+	error ("Cannot resolve method %s%s%s to any overloaded instance",
+	       obj_type_name,
+	       (obj_type_name && *obj_type_name) ? "::" : "",
+	       name);
+      else
+	error ("Cannot resolve function %s to any overloaded instance",
+	       func_name);
+    }
+  else if (oload_non_standard)
+    {
+      if (method)
+	warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
+		 obj_type_name,
+		 (obj_type_name && *obj_type_name) ? "::" : "",
+		 name);
+      else
+	warning ("Using non-standard conversion to match function %s to supplied arguments",
+		 func_name);
+    }
+
+  if (method)
+    {
+      if (staticp && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ))
+	*staticp = 1;
+      else if (staticp)
+	*staticp = 0;
+      if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
+	*valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
+      else
+	*valp = value_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
+    }
+  else
+    {
+      *symp = oload_syms[oload_champ];
+      xfree (func_name);
+    }
+
+  if (objp)
+    {
+      if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR
+	  && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR)
+	{
+	  temp = value_addr (temp);
+	}
+      *objp = temp;
+    }
+  if (cleanups != NULL)
+    do_cleanups (cleanups);
+
+  return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
+}
+
+/* C++: return 1 is NAME is a legitimate name for the destructor
+   of type TYPE.  If TYPE does not have a destructor, or
+   if NAME is inappropriate for TYPE, an error is signaled.  */
+int
+destructor_name_p (const char *name, const struct type *type)
+{
+  /* destructors are a special case.  */
+
+  if (name[0] == '~')
+    {
+      char *dname = type_name_no_tag (type);
+      char *cp = strchr (dname, '<');
+      unsigned int len;
+
+      /* Do not compare the template part for template classes.  */
+      if (cp == NULL)
+	len = strlen (dname);
+      else
+	len = cp - dname;
+      if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
+	error ("name of destructor must equal name of class");
+      else
+	return 1;
+    }
+  return 0;
+}
+
+/* Helper function for check_field: Given TYPE, a structure/union,
+   return 1 if the component named NAME from the ultimate
+   target structure/union is defined, otherwise, return 0. */
+
+static int
+check_field_in (register struct type *type, const char *name)
+{
+  register int i;
+
+  for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
+    {
+      char *t_field_name = TYPE_FIELD_NAME (type, i);
+      if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
+	return 1;
+    }
+
+  /* C++: If it was not found as a data field, then try to
+     return it as a pointer to a method.  */
+
+  /* Destructors are a special case.  */
+  if (destructor_name_p (name, type))
+    {
+      int m_index, f_index;
+
+      return get_destructor_fn_field (type, &m_index, &f_index);
+    }
+
+  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
+    {
+      if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
+	return 1;
+    }
+
+  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
+    if (check_field_in (TYPE_BASECLASS (type, i), name))
+      return 1;
+
+  return 0;
+}
+
+
+/* C++: Given ARG1, a value of type (pointer to a)* structure/union,
+   return 1 if the component named NAME from the ultimate
+   target structure/union is defined, otherwise, return 0.  */
+
+int
+check_field (struct value *arg1, const char *name)
+{
+  register struct type *t;
+
+  COERCE_ARRAY (arg1);
+
+  t = VALUE_TYPE (arg1);
+
+  /* Follow pointers until we get to a non-pointer.  */
+
+  for (;;)
+    {
+      CHECK_TYPEDEF (t);
+      if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF)
+	break;
+      t = TYPE_TARGET_TYPE (t);
+    }
+
+  if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
+    error ("not implemented: member type in check_field");
+
+  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
+      && TYPE_CODE (t) != TYPE_CODE_UNION)
+    error ("Internal error: `this' is not an aggregate");
+
+  return check_field_in (t, name);
+}
+
+/* C++: Given an aggregate type CURTYPE, and a member name NAME,
+   return the address of this member as a "pointer to member"
+   type.  If INTYPE is non-null, then it will be the type
+   of the member we are looking for.  This will help us resolve
+   "pointers to member functions".  This function is used
+   to resolve user expressions of the form "DOMAIN::NAME".  */
+
+struct value *
+value_struct_elt_for_reference (struct type *domain, int offset,
+				struct type *curtype, char *name,
+				struct type *intype)
+{
+  register struct type *t = curtype;
+  register int i;
+  struct value *v;
+
+  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
+      && TYPE_CODE (t) != TYPE_CODE_UNION)
+    error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
+
+  for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
+    {
+      char *t_field_name = TYPE_FIELD_NAME (t, i);
+
+      if (t_field_name && STREQ (t_field_name, name))
+	{
+	  if (TYPE_FIELD_STATIC (t, i))
+	    {
+	      v = value_static_field (t, i);
+	      if (v == NULL)
+		error ("static field %s has been optimized out",
+		       name);
+	      return v;
+	    }
+	  if (TYPE_FIELD_PACKED (t, i))
+	    error ("pointers to bitfield members not allowed");
+
+	  return value_from_longest
+	    (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
+							domain)),
+	     offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
+	}
+    }
+
+  /* C++: If it was not found as a data field, then try to
+     return it as a pointer to a method.  */
+
+  /* Destructors are a special case.  */
+  if (destructor_name_p (name, t))
+    {
+      error ("member pointers to destructors not implemented yet");
+    }
+
+  /* Perform all necessary dereferencing.  */
+  while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
+    intype = TYPE_TARGET_TYPE (intype);
+
+  for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
+    {
+      char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
+      char dem_opname[64];
+
+      if (strncmp (t_field_name, "__", 2) == 0 ||
+	  strncmp (t_field_name, "op", 2) == 0 ||
+	  strncmp (t_field_name, "type", 4) == 0)
+	{
+	  if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
+	    t_field_name = dem_opname;
+	  else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
+	    t_field_name = dem_opname;
+	}
+      if (t_field_name && STREQ (t_field_name, name))
+	{
+	  int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
+	  struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
+
+	  check_stub_method_group (t, i);
+
+	  if (intype == 0 && j > 1)
+	    error ("non-unique member `%s' requires type instantiation", name);
+	  if (intype)
+	    {
+	      while (j--)
+		if (TYPE_FN_FIELD_TYPE (f, j) == intype)
+		  break;
+	      if (j < 0)
+		error ("no member function matches that type instantiation");
+	    }
+	  else
+	    j = 0;
+
+	  if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
+	    {
+	      return value_from_longest
+		(lookup_reference_type
+		 (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
+				      domain)),
+		 (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
+	    }
+	  else
+	    {
+	      struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
+						0, VAR_NAMESPACE, 0, NULL);
+	      if (s == NULL)
+		{
+		  v = 0;
+		}
+	      else
+		{
+		  v = read_var_value (s, 0);
+#if 0
+		  VALUE_TYPE (v) = lookup_reference_type
+		    (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
+					 domain));
+#endif
+		}
+	      return v;
+	    }
+	}
+    }
+  for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
+    {
+      struct value *v;
+      int base_offset;
+
+      if (BASETYPE_VIA_VIRTUAL (t, i))
+	base_offset = 0;
+      else
+	base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
+      v = value_struct_elt_for_reference (domain,
+					  offset + base_offset,
+					  TYPE_BASECLASS (t, i),
+					  name,
+					  intype);
+      if (v)
+	return v;
+    }
+  return 0;
+}
+
+
+/* Given a pointer value V, find the real (RTTI) type
+   of the object it points to.
+   Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
+   and refer to the values computed for the object pointed to. */
+
+struct type *
+value_rtti_target_type (struct value *v, int *full, int *top, int *using_enc)
+{
+  struct value *target;
+
+  target = value_ind (v);
+
+  return value_rtti_type (target, full, top, using_enc);
+}
+
+/* Given a value pointed to by ARGP, check its real run-time type, and
+   if that is different from the enclosing type, create a new value
+   using the real run-time type as the enclosing type (and of the same
+   type as ARGP) and return it, with the embedded offset adjusted to
+   be the correct offset to the enclosed object
+   RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
+   parameters, computed by value_rtti_type(). If these are available,
+   they can be supplied and a second call to value_rtti_type() is avoided.
+   (Pass RTYPE == NULL if they're not available */
+
+struct value *
+value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop,
+		   int xusing_enc)
+{
+  struct type *real_type;
+  int full = 0;
+  int top = -1;
+  int using_enc = 0;
+  struct value *new_val;
+
+  if (rtype)
+    {
+      real_type = rtype;
+      full = xfull;
+      top = xtop;
+      using_enc = xusing_enc;
+    }
+  else
+    real_type = value_rtti_type (argp, &full, &top, &using_enc);
+
+  /* If no RTTI data, or if object is already complete, do nothing */
+  if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
+    return argp;
+
+  /* If we have the full object, but for some reason the enclosing
+     type is wrong, set it *//* pai: FIXME -- sounds iffy */
+  if (full)
+    {
+      argp = value_change_enclosing_type (argp, real_type);
+      return argp;
+    }
+
+  /* Check if object is in memory */
+  if (VALUE_LVAL (argp) != lval_memory)
+    {
+      warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
+
+      return argp;
+    }
+
+  /* All other cases -- retrieve the complete object */
+  /* Go back by the computed top_offset from the beginning of the object,
+     adjusting for the embedded offset of argp if that's what value_rtti_type
+     used for its computation. */
+  new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
+			   (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
+			   VALUE_BFD_SECTION (argp));
+  VALUE_TYPE (new_val) = VALUE_TYPE (argp);
+  VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
+  return new_val;
+}
+
+
+
+
+/* C++: return the value of the class instance variable, if one exists.
+   Flag COMPLAIN signals an error if the request is made in an
+   inappropriate context.  */
+
+struct value *
+value_of_this (int complain)
+{
+  struct symbol *func, *sym;
+  struct block *b;
+  int i;
+  static const char funny_this[] = "this";
+  struct value *this;
+
+  if (selected_frame == 0)
+    {
+      if (complain)
+	error ("no frame selected");
+      else
+	return 0;
+    }
+
+  func = get_frame_function (selected_frame);
+  if (!func)
+    {
+      if (complain)
+	error ("no `this' in nameless context");
+      else
+	return 0;
+    }
+
+  b = SYMBOL_BLOCK_VALUE (func);
+  i = BLOCK_NSYMS (b);
+  if (i <= 0)
+    {
+      if (complain)
+	error ("no args, no `this'");
+      else
+	return 0;
+    }
+
+  /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
+     symbol instead of the LOC_ARG one (if both exist).  */
+  sym = lookup_block_symbol (b, funny_this, NULL, VAR_NAMESPACE);
+  if (sym == NULL)
+    {
+      if (complain)
+	error ("current stack frame not in method");
+      else
+	return NULL;
+    }
+
+  this = read_var_value (sym, selected_frame);
+  if (this == 0 && complain)
+    error ("`this' argument at unknown address");
+  return this;
+}
+
+/* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
+   long, starting at LOWBOUND.  The result has the same lower bound as
+   the original ARRAY.  */
+
+struct value *
+value_slice (struct value *array, int lowbound, int length)
+{
+  struct type *slice_range_type, *slice_type, *range_type;
+  LONGEST lowerbound, upperbound, offset;
+  struct value *slice;
+  struct type *array_type;
+  array_type = check_typedef (VALUE_TYPE (array));
+  COERCE_VARYING_ARRAY (array, array_type);
+  if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
+      && TYPE_CODE (array_type) != TYPE_CODE_STRING
+      && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
+    error ("cannot take slice of non-array");
+  range_type = TYPE_INDEX_TYPE (array_type);
+  if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
+    error ("slice from bad array or bitstring");
+  if (lowbound < lowerbound || length < 0
+      || lowbound + length - 1 > upperbound)
+    /* OBSOLETE Chill allows zero-length strings but not arrays. */
+    /* OBSOLETE || (current_language->la_language == language_chill */
+    /* OBSOLETE && length == 0 && TYPE_CODE (array_type) == TYPE_CODE_ARRAY)) */
+    error ("slice out of range");
+  /* FIXME-type-allocation: need a way to free this type when we are
+     done with it.  */
+  slice_range_type = create_range_type ((struct type *) NULL,
+					TYPE_TARGET_TYPE (range_type),
+					lowbound, lowbound + length - 1);
+  if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
+    {
+      int i;
+      slice_type = create_set_type ((struct type *) NULL, slice_range_type);
+      TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
+      slice = value_zero (slice_type, not_lval);
+      for (i = 0; i < length; i++)
+	{
+	  int element = value_bit_index (array_type,
+					 VALUE_CONTENTS (array),
+					 lowbound + i);
+	  if (element < 0)
+	    error ("internal error accessing bitstring");
+	  else if (element > 0)
+	    {
+	      int j = i % TARGET_CHAR_BIT;
+	      if (BITS_BIG_ENDIAN)
+		j = TARGET_CHAR_BIT - 1 - j;
+	      VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
+	    }
+	}
+      /* We should set the address, bitssize, and bitspos, so the clice
+         can be used on the LHS, but that may require extensions to
+         value_assign.  For now, just leave as a non_lval.  FIXME.  */
+    }
+  else
+    {
+      struct type *element_type = TYPE_TARGET_TYPE (array_type);
+      offset
+	= (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
+      slice_type = create_array_type ((struct type *) NULL, element_type,
+				      slice_range_type);
+      TYPE_CODE (slice_type) = TYPE_CODE (array_type);
+      slice = allocate_value (slice_type);
+      if (VALUE_LAZY (array))
+	VALUE_LAZY (slice) = 1;
+      else
+	memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
+		TYPE_LENGTH (slice_type));
+      if (VALUE_LVAL (array) == lval_internalvar)
+	VALUE_LVAL (slice) = lval_internalvar_component;
+      else
+	VALUE_LVAL (slice) = VALUE_LVAL (array);
+      VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
+      VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
+    }
+  return slice;
+}
+
+/* Assuming OBSOLETE chill_varying_type (VARRAY) is true, return an
+   equivalent value as a fixed-length array. */
+
+struct value *
+varying_to_slice (struct value *varray)
+{
+  struct type *vtype = check_typedef (VALUE_TYPE (varray));
+  LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
+				VALUE_CONTENTS (varray)
+				+ TYPE_FIELD_BITPOS (vtype, 0) / 8);
+  return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
+}
+
+/* Create a value for a FORTRAN complex number.  Currently most of
+   the time values are coerced to COMPLEX*16 (i.e. a complex number
+   composed of 2 doubles.  This really should be a smarter routine
+   that figures out precision inteligently as opposed to assuming
+   doubles. FIXME: fmb */
+
+struct value *
+value_literal_complex (struct value *arg1, struct value *arg2, struct type *type)
+{
+  struct value *val;
+  struct type *real_type = TYPE_TARGET_TYPE (type);
+
+  val = allocate_value (type);
+  arg1 = value_cast (real_type, arg1);
+  arg2 = value_cast (real_type, arg2);
+
+  memcpy (VALUE_CONTENTS_RAW (val),
+	  VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
+  memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
+	  VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
+  return val;
+}
+
+/* Cast a value into the appropriate complex data type. */
+
+static struct value *
+cast_into_complex (struct type *type, struct value *val)
+{
+  struct type *real_type = TYPE_TARGET_TYPE (type);
+  if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
+    {
+      struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
+      struct value *re_val = allocate_value (val_real_type);
+      struct value *im_val = allocate_value (val_real_type);
+
+      memcpy (VALUE_CONTENTS_RAW (re_val),
+	      VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
+      memcpy (VALUE_CONTENTS_RAW (im_val),
+	      VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
+	      TYPE_LENGTH (val_real_type));
+
+      return value_literal_complex (re_val, im_val, type);
+    }
+  else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
+	   || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
+    return value_literal_complex (val, value_zero (real_type, not_lval), type);
+  else
+    error ("cannot cast non-number to complex");
+}
+
+void
+_initialize_valops (void)
+{
+#if 0
+  add_show_from_set
+    (add_set_cmd ("abandon", class_support, var_boolean, (char *) &auto_abandon,
+		  "Set automatic abandonment of expressions upon failure.",
+		  &setlist),
+     &showlist);
+#endif
+
+  add_show_from_set
+    (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *) &overload_resolution,
+		  "Set overload resolution in evaluating C++ functions.",
+		  &setlist),
+     &showlist);
+  overload_resolution = 1;
+
+  add_show_from_set (
+  add_set_cmd ("unwindonsignal", no_class, var_boolean,
+	       (char *) &unwind_on_signal_p,
+"Set unwinding of stack if a signal is received while in a call dummy.\n\
+The unwindonsignal lets the user determine what gdb should do if a signal\n\
+is received while in a function called from gdb (call dummy).  If set, gdb\n\
+unwinds the stack and restore the context to what as it was before the call.\n\
+The default is to stop in the frame where the signal was received.", &setlist),
+		     &showlist);
+}