1 files changed, 158 insertions, 179 deletions

diff --git a/contrib/gdb/gdb/corefile.c b/contrib/gdb/gdb/corefile.c
index 94e56eb..7acbd6e 100644
--- a/contrib/gdb/gdb/corefile.c
+++ b/contrib/gdb/gdb/corefile.c
@@ -1,29 +1,30 @@
 /* Core dump and executable file functions above target vector, for GDB.
-   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994
+   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
+   1999, 2000, 2001
    Free Software Foundation, Inc.
 
-This file is part of GDB.
+   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 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.
+   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.  */
+   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 <errno.h>
 #include <signal.h>
 #include <fcntl.h>
-#include "frame.h"  /* required by inferior.h */
 #include "inferior.h"
 #include "symtab.h"
 #include "command.h"
@@ -32,16 +33,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "target.h"
 #include "gdbcore.h"
 #include "dis-asm.h"
-#include "language.h"
 #include "gdb_stat.h"
-#include "symfile.h"
-#include "objfiles.h"
-
-extern char registers[];
+#include "completer.h"
 
 /* Local function declarations.  */
 
-static void call_extra_exec_file_hooks PARAMS ((char *filename));
+extern void _initialize_core (void);
+static void call_extra_exec_file_hooks (char *filename);
 
 /* You can have any number of hooks for `exec_file_command' command to call.
    If there's only one hook, it is set in exec_file_display hook.
@@ -51,80 +49,54 @@ static void call_extra_exec_file_hooks PARAMS ((char *filename));
    old code that assumed that only one hook could be set, and which called
    exec_file_display_hook directly.  */
 
-typedef void (*hook_type) PARAMS ((char *));
+typedef void (*hook_type) (char *);
 
-hook_type exec_file_display_hook;		/* the original hook */
+hook_type exec_file_display_hook;	/* the original hook */
 static hook_type *exec_file_extra_hooks;	/* array of additional hooks */
-static int exec_file_hook_count = 0;		/* size of array */
+static int exec_file_hook_count = 0;	/* size of array */
 
 /* Binary file diddling handle for the core file.  */
 
 bfd *core_bfd = NULL;
-
 
+
 /* Backward compatability with old way of specifying core files.  */
 
 void
-core_file_command (filename, from_tty)
-     char *filename;
-     int from_tty;
+core_file_command (char *filename, int from_tty)
 {
   struct target_ops *t;
 
-  dont_repeat ();			/* Either way, seems bogus. */
+  dont_repeat ();		/* Either way, seems bogus. */
 
   t = find_core_target ();
-  if (t != NULL)
-    if (!filename)
-      (t->to_detach) (filename, from_tty);
-    else
-      {
-        /* Yes, we were given the path of a core file.  Do we already
-           have a symbol file?  If not, can we determine it from the
-           core file?  If we can, do so.
-           */
-#ifdef HPUXHPPA
-        if (symfile_objfile == NULL)
-          {
-            char *  symfile;
-            symfile = t->to_core_file_to_sym_file (filename);
-            if (symfile)
-              {
-                char *  symfile_copy = strdup (symfile);
-
-                make_cleanup (free, symfile_copy);
-                symbol_file_command (symfile_copy, from_tty);
-              }
-            else
-              warning ("Unknown symbols for '%s'; use the 'symbol-file' command.", filename);
-          }
-#endif
-        (t->to_open) (filename, from_tty);
-      }
-  else
+  if (t == NULL)
     error ("GDB can't read core files on this machine.");
-}
 
+  if (!filename)
+    (t->to_detach) (filename, from_tty);
+  else
+    (t->to_open) (filename, from_tty);
+}
 
+
 /* If there are two or more functions that wish to hook into exec_file_command,
  * this function will call all of the hook functions. */
 
 static void
-call_extra_exec_file_hooks (filename)
-     char *filename;
+call_extra_exec_file_hooks (char *filename)
 {
   int i;
 
   for (i = 0; i < exec_file_hook_count; i++)
-    (*exec_file_extra_hooks[i])(filename);
+    (*exec_file_extra_hooks[i]) (filename);
 }
 
 /* Call this to specify the hook for exec_file_command to call back.
    This is called from the x-window display code.  */
 
 void
-specify_exec_file_hook (hook)
-     void (*hook) PARAMS ((char *));
+specify_exec_file_hook (void (*hook) (char *))
 {
   hook_type *new_array;
 
@@ -135,7 +107,7 @@ specify_exec_file_hook (hook)
       if (exec_file_hook_count == 0)
 	{
 	  /* If this is the first extra hook, initialize the hook array. */
-	  exec_file_extra_hooks = (hook_type *) xmalloc (sizeof(hook_type));
+	  exec_file_extra_hooks = (hook_type *) xmalloc (sizeof (hook_type));
 	  exec_file_extra_hooks[0] = exec_file_display_hook;
 	  exec_file_display_hook = call_extra_exec_file_hooks;
 	  exec_file_hook_count = 1;
@@ -147,7 +119,7 @@ specify_exec_file_hook (hook)
       exec_file_hook_count++;
       new_array =
 	(hook_type *) xrealloc (exec_file_extra_hooks,
-				exec_file_hook_count * sizeof(hook_type));
+				exec_file_hook_count * sizeof (hook_type));
       exec_file_extra_hooks = new_array;
       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
     }
@@ -160,18 +132,18 @@ specify_exec_file_hook (hook)
    be reopened.  */
 
 void
-close_exec_file ()
+close_exec_file (void)
 {
-#if 0 /* FIXME */
+#if 0				/* FIXME */
   if (exec_bfd)
     bfd_tempclose (exec_bfd);
 #endif
 }
 
 void
-reopen_exec_file ()
+reopen_exec_file (void)
 {
-#if 0 /* FIXME */
+#if 0				/* FIXME */
   if (exec_bfd)
     bfd_reopen (exec_bfd);
 #else
@@ -183,15 +155,17 @@ reopen_exec_file ()
   /* Don't do anything if the current target isn't exec. */
   if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0)
     return;
- 
+
   /* If the timestamp of the exec file has changed, reopen it. */
-  filename = strdup (bfd_get_filename (exec_bfd));
-  make_cleanup (free, filename);
-  mtime = bfd_get_mtime(exec_bfd);
+  filename = xstrdup (bfd_get_filename (exec_bfd));
+  make_cleanup (xfree, filename);
+  mtime = bfd_get_mtime (exec_bfd);
   res = stat (filename, &st);
 
   if (mtime && mtime != st.st_mtime)
-    exec_file_command (filename, 0);
+    {
+      exec_open (filename, 0);
+    }
 #endif
 }
 
@@ -199,13 +173,13 @@ reopen_exec_file ()
    print a warning if they don't go together.  */
 
 void
-validate_files ()
+validate_files (void)
 {
   if (exec_bfd && core_bfd)
     {
       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 	warning ("core file may not match specified executable file.");
-      else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd))
+      else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
 	warning ("exec file is newer than core file.");
     }
 }
@@ -215,52 +189,48 @@ validate_files ()
    otherwise return 0 in that case.  */
 
 char *
-get_exec_file (err)
-     int err;
+get_exec_file (int err)
 {
-  if (exec_bfd) return bfd_get_filename(exec_bfd);
-  if (!err)     return NULL;
+  if (exec_bfd)
+    return bfd_get_filename (exec_bfd);
+  if (!err)
+    return NULL;
 
   error ("No executable file specified.\n\
 Use the \"file\" or \"exec-file\" command.");
   return NULL;
 }
-
 
+
 /* Report a memory error with error().  */
 
 void
-memory_error (status, memaddr)
-     int status;
-     CORE_ADDR memaddr;
+memory_error (int status, CORE_ADDR memaddr)
 {
+  struct ui_file *tmp_stream = mem_fileopen ();
+  make_cleanup_ui_file_delete (tmp_stream);
+
   if (status == EIO)
     {
       /* Actually, address between memaddr and memaddr + len
-	 was out of bounds. */
-      error_begin ();
-      printf_filtered ("Cannot access memory at address ");
-      print_address_numeric (memaddr, 1, gdb_stdout);
-      printf_filtered (".\n");
-      return_to_top_level (RETURN_ERROR);
+         was out of bounds. */
+      fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
+      print_address_numeric (memaddr, 1, tmp_stream);
     }
   else
     {
-      error_begin ();
-      printf_filtered ("Error accessing memory address ");
-      print_address_numeric (memaddr, 1, gdb_stdout);
-      printf_filtered (": %s.\n",
-			 safe_strerror (status));
-      return_to_top_level (RETURN_ERROR);
+      fprintf_filtered (tmp_stream, "Error accessing memory address ");
+      print_address_numeric (memaddr, 1, tmp_stream);
+      fprintf_filtered (tmp_stream, ": %s.",
+		       safe_strerror (status));
     }
+
+  error_stream (tmp_stream);
 }
 
 /* Same as target_read_memory, but report an error if can't read.  */
 void
-read_memory (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+read_memory (CORE_ADDR memaddr, char *myaddr, int len)
 {
   int status;
   status = target_read_memory (memaddr, myaddr, len);
@@ -268,70 +238,67 @@ read_memory (memaddr, myaddr, len)
     memory_error (status, memaddr);
 }
 
-void
-read_memory_section (memaddr, myaddr, len, bfd_section)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     asection *bfd_section;
-{
-  int status;
-  status = target_read_memory_section (memaddr, myaddr, len, bfd_section);
-  if (status != 0)
-    memory_error (status, memaddr);
-}
-
 /* Like target_read_memory, but slightly different parameters.  */
-
 int
-dis_asm_read_memory (memaddr, myaddr, len, info)
-     bfd_vma memaddr;
-     bfd_byte *myaddr;
-     int len;
-     disassemble_info *info;
+dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len,
+		     disassemble_info *info)
 {
   return target_read_memory (memaddr, (char *) myaddr, len);
 }
 
 /* Like memory_error with slightly different parameters.  */
 void
-dis_asm_memory_error (status, memaddr, info)
-     int status;
-     bfd_vma memaddr;
-     disassemble_info *info;
+dis_asm_memory_error (int status, bfd_vma memaddr, disassemble_info *info)
 {
   memory_error (status, memaddr);
 }
 
 /* Like print_address with slightly different parameters.  */
 void
-dis_asm_print_address (addr, info)
-     bfd_vma addr;
-     struct disassemble_info *info;
+dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
 {
   print_address (addr, info->stream);
 }
 
-/* Same as target_write_memory, but report an error if can't write.  */
-void
-write_memory (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+/* Read an integer from debugged memory, given address and number of bytes.  */
+
+struct captured_read_memory_integer_arguments
 {
-  int status;
+  CORE_ADDR memaddr;
+  int len;
+  LONGEST result;
+};
 
-  status = target_write_memory (memaddr, myaddr, len);
-  if (status != 0)
-    memory_error (status, memaddr);
+static int
+do_captured_read_memory_integer (void *data)
+{
+  struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
+  CORE_ADDR memaddr = args->memaddr;
+  int len = args->len;
+
+  args->result = read_memory_integer (memaddr, len);
+
+  return 0;
 }
 
-/* Read an integer from debugged memory, given address and number of bytes.  */
+int
+safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
+{
+  int status;
+  struct captured_read_memory_integer_arguments args;
+  args.memaddr = memaddr;
+  args.len = len;
+
+  status = catch_errors (do_captured_read_memory_integer, &args,
+                        "", RETURN_MASK_ALL);
+  if (!status)
+    *return_value = args.result;
+
+  return status;
+}
 
 LONGEST
-read_memory_integer (memaddr, len)
-     CORE_ADDR memaddr;
-     int len;
+read_memory_integer (CORE_ADDR memaddr, int len)
 {
   char buf[sizeof (LONGEST)];
 
@@ -340,9 +307,7 @@ read_memory_integer (memaddr, len)
 }
 
 ULONGEST
-read_memory_unsigned_integer (memaddr, len)
-     CORE_ADDR memaddr;
-     int len;
+read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
 {
   char buf[sizeof (ULONGEST)];
 
@@ -351,12 +316,9 @@ read_memory_unsigned_integer (memaddr, len)
 }
 
 void
-read_memory_string (memaddr, buffer, max_len)
-     CORE_ADDR memaddr;
-     char * buffer;
-     int max_len;
+read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 {
-  register char * cp;
+  register char *cp;
   register int i;
   int cnt;
 
@@ -364,23 +326,53 @@ read_memory_string (memaddr, buffer, max_len)
   while (1)
     {
       if (cp - buffer >= max_len)
-        {
-          buffer[max_len - 1] = '\0';
-          break;
-        }
+	{
+	  buffer[max_len - 1] = '\0';
+	  break;
+	}
       cnt = max_len - (cp - buffer);
       if (cnt > 8)
 	cnt = 8;
       read_memory (memaddr + (int) (cp - buffer), cp, cnt);
       for (i = 0; i < cnt && *cp; i++, cp++)
-        ; /* null body */
+	;			/* null body */
 
       if (i < cnt && !*cp)
-        break;
+	break;
     }
 }
 
+/* Same as target_write_memory, but report an error if can't write.  */
+void
+write_memory (CORE_ADDR memaddr, char *myaddr, int len)
+{
+  int status;
+
+  status = target_write_memory (memaddr, myaddr, len);
+  if (status != 0)
+    memory_error (status, memaddr);
+}
+
+/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer.  */
+void
+write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value)
+{
+  char *buf = alloca (len);
+  store_unsigned_integer (buf, len, value);
+  write_memory (addr, buf, len);
+}
+
+/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer.  */
+void
+write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value)
+{
+  char *buf = alloca (len);
+  store_signed_integer (buf, len, value);
+  write_memory (addr, buf, len);
+}
+
 
+
 #if 0
 /* Enable after 4.12.  It is not tested.  */
 
@@ -388,17 +380,9 @@ read_memory_string (memaddr, buffer, max_len)
    if the protocol has a less general search function, they can call this
    in the cases it can't handle.  */
 void
-generic_search (len, data, mask, startaddr, increment, lorange, hirange
-		addr_found, data_found)
-     int len;
-     char *data;
-     char *mask;
-     CORE_ADDR startaddr;
-     int increment;
-     CORE_ADDR lorange;
-     CORE_ADDR hirange;
-     CORE_ADDR *addr_found;
-     char *data_found;
+generic_search (int len, char *data, char *mask, CORE_ADDR startaddr,
+		int increment, CORE_ADDR lorange, CORE_ADDR hirange,
+		CORE_ADDR *addr_found, char *data_found)
 {
   int i;
   CORE_ADDR curaddr = startaddr;
@@ -416,7 +400,7 @@ generic_search (len, data, mask, startaddr, increment, lorange, hirange
     try_again:
       curaddr += increment;
     }
-  *addr_found = (CORE_ADDR)0;
+  *addr_found = (CORE_ADDR) 0;
   return;
 }
 #endif /* 0 */
@@ -428,14 +412,10 @@ char *gnutarget;
 /* Same thing, except it is "auto" not NULL for the default case.  */
 static char *gnutarget_string;
 
-static void set_gnutarget_command
-  PARAMS ((char *, int, struct cmd_list_element *));
+static void set_gnutarget_command (char *, int, struct cmd_list_element *);
 
 static void
-set_gnutarget_command (ignore, from_tty, c)
-     char *ignore;
-     int from_tty;
-     struct cmd_list_element *c;
+set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
 {
   if (STREQ (gnutarget_string, "auto"))
     gnutarget = NULL;
@@ -445,17 +425,16 @@ set_gnutarget_command (ignore, from_tty, c)
 
 /* Set the gnutarget.  */
 void
-set_gnutarget (newtarget)
-     char *newtarget;
+set_gnutarget (char *newtarget)
 {
   if (gnutarget_string != NULL)
-    free (gnutarget_string);
+    xfree (gnutarget_string);
   gnutarget_string = savestring (newtarget, strlen (newtarget));
   set_gnutarget_command (NULL, 0, NULL);
 }
 
 void
-_initialize_core()
+_initialize_core (void)
 {
   struct cmd_list_element *c;
   c = add_cmd ("core-file", class_files, core_file_command,
@@ -465,11 +444,11 @@ No arg means have no core file.  This command has been superseded by the\n\
   c->completer = filename_completer;
 
   c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
-		  (char *) &gnutarget_string,
-		  "Set the current BFD target.\n\
+		   (char *) &gnutarget_string,
+		   "Set the current BFD target.\n\
 Use `set gnutarget auto' to specify automatic detection.",
-		  &setlist);
-  c->function.sfunc = set_gnutarget_command;
+		   &setlist);
+  set_cmd_sfunc (c, set_gnutarget_command);
   add_show_from_set (c, &showlist);
 
   if (getenv ("GNUTARGET"))