gdb/testsuite/

[binutils-gdb.git] / gdb / corefile.c

diff --git a/gdb/corefile.c b/gdb/corefile.c
index b4801d051eb21ce9e2322c56dab914afe3caa1f8..c6efba7da2583cd9af6d5063054e29ea45e19ff2 100644 (file)
--- a/gdb/corefile.c
+++ b/gdb/corefile.c
@@ -1,13 +1,14 @@
 /* Core dump and executable file functions above target vector, for GDB.
 
 /* Core dump and executable file functions above target vector, for GDB.
 

-   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997,
-   1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
+   Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
+   1999, 2000, 2001, 2003, 2006, 2007, 2008, 2009, 2010
+   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
 
    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
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,9 +17,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "gdb_string.h"
 
 #include "defs.h"
 #include "gdb_string.h"


@@ -60,6 +59,10 @@ static int exec_file_hook_count = 0; /* size of array */
 /* Binary file diddling handle for the core file.  */
 
 bfd *core_bfd = NULL;
 /* Binary file diddling handle for the core file.  */
 
 bfd *core_bfd = NULL;

+
+/* corelow.c target (if included for this gdb target).  */
+
+struct target_ops *core_target;

 \f
 
 /* Backward compatability with old way of specifying core files.  */
 \f
 
 /* Backward compatability with old way of specifying core files.  */


@@ -67,18 +70,15 @@ bfd *core_bfd = NULL;
 void
 core_file_command (char *filename, int from_tty)
 {
 void
 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 (core_target == NULL)

     error (_("GDB can't read core files on this machine."));
 
   if (!filename)
     error (_("GDB can't read core files on this machine."));
 
   if (!filename)

-    (t->to_detach) (filename, from_tty);
+    (core_target->to_detach) (core_target, filename, from_tty);

   else
   else

-    (t->to_open) (filename, from_tty);
+    (core_target->to_open) (filename, from_tty);

 }
 \f
 
 }
 \f
 


@@ -153,22 +153,26 @@ reopen_exec_file (void)
   char *filename;
   int res;
   struct stat st;
   char *filename;
   int res;
   struct stat st;

-  long mtime;
+  struct cleanup *cleanups;

 
 

-  /* Don't do anything if the current target isn't exec. */
-  if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0)
+  /* Don't do anything if there isn't an exec file. */
+  if (exec_bfd == NULL)

     return;
 
   /* If the timestamp of the exec file has changed, reopen it. */
   filename = xstrdup (bfd_get_filename (exec_bfd));
     return;
 
   /* If the timestamp of the exec file has changed, reopen it. */
   filename = xstrdup (bfd_get_filename (exec_bfd));

-  make_cleanup (xfree, filename);
-  mtime = bfd_get_mtime (exec_bfd);
+  cleanups = make_cleanup (xfree, filename);

   res = stat (filename, &st);
 
   res = stat (filename, &st);
 

-  if (mtime && mtime != st.st_mtime)
-    {
-      exec_open (filename, 0);
-    }
+  if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
+    exec_file_attach (filename, 0);
+  else
+    /* If we accessed the file since last opening it, close it now;
+       this stops GDB from holding the executable open after it
+       exits.  */
+    bfd_cache_close_all ();
+
+  do_cleanups (cleanups);

 #endif
 }
 \f
 #endif
 }
 \f


@@ -205,42 +209,48 @@ Use the \"file\" or \"exec-file\" command."));
 }
 \f
 
 }
 \f
 

-/* Report a memory error with error().  */
+/* Report a memory error by throwing a MEMORY_ERROR error.  */

 
 void
 memory_error (int status, CORE_ADDR memaddr)
 {
 
 void
 memory_error (int status, CORE_ADDR memaddr)
 {

-  struct ui_file *tmp_stream = mem_fileopen ();
-  make_cleanup_ui_file_delete (tmp_stream);
-

   if (status == EIO)
   if (status == EIO)

-    {
-      /* Actually, address between memaddr and memaddr + len
-         was out of bounds. */
-      fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
-      print_address_numeric (memaddr, 1, tmp_stream);
-    }
+    /* Actually, address between memaddr and memaddr + len was out of
+       bounds.  */
+    throw_error (MEMORY_ERROR,
+                _("Cannot access memory at address %s"),
+                paddress (target_gdbarch, memaddr));

   else
   else

-    {
-      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);
+    throw_error (MEMORY_ERROR,
+                _("Error accessing memory address %s: %s."),
+                paddress (target_gdbarch, memaddr),
+                safe_strerror (status));

 }
 
 /* Same as target_read_memory, but report an error if can't read.  */
 }
 
 /* Same as target_read_memory, but report an error if can't read.  */

+

 void
 void

-read_memory (CORE_ADDR memaddr, char *myaddr, int len)
+read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)

 {
   int status;
 {
   int status;

+

   status = target_read_memory (memaddr, myaddr, len);
   if (status != 0)
     memory_error (status, memaddr);
 }
 
   status = target_read_memory (memaddr, myaddr, len);
   if (status != 0)
     memory_error (status, memaddr);
 }
 

+/* Same as target_read_stack, but report an error if can't read.  */
+
+void
+read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+{
+  int status;
+
+  status = target_read_stack (memaddr, myaddr, len);
+  if (status != 0)
+    memory_error (status, memaddr);
+}
+

 /* Argument / return result struct for use with
    do_captured_read_memory_integer().  MEMADDR and LEN are filled in
    by gdb_read_memory_integer().  RESULT is the contents that were
 /* Argument / return result struct for use with
    do_captured_read_memory_integer().  MEMADDR and LEN are filled in
    by gdb_read_memory_integer().  RESULT is the contents that were


@@ -250,6 +260,7 @@ struct captured_read_memory_integer_arguments
 {
   CORE_ADDR memaddr;
   int len;
 {
   CORE_ADDR memaddr;
   int len;

+  enum bfd_endian byte_order;

   LONGEST result;
 };
 
   LONGEST result;
 };
 


@@ -266,8 +277,9 @@ 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;
   struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
   CORE_ADDR memaddr = args->memaddr;
   int len = args->len;

+  enum bfd_endian byte_order = args->byte_order;

 
 

-  args->result = read_memory_integer (memaddr, len);
+  args->result = read_memory_integer (memaddr, len, byte_order);

 
   return 1;
 }
 
   return 1;
 }


@@ -277,12 +289,16 @@ do_captured_read_memory_integer (void *data)
    if successful.  */
 
 int
    if successful.  */
 
 int

-safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
+safe_read_memory_integer (CORE_ADDR memaddr, int len, 
+                         enum bfd_endian byte_order,
+                         LONGEST *return_value)

 {
   int status;
   struct captured_read_memory_integer_arguments args;
 {
   int status;
   struct captured_read_memory_integer_arguments args;

+

   args.memaddr = memaddr;
   args.len = len;
   args.memaddr = memaddr;
   args.len = len;

+  args.byte_order = byte_order;

 
   status = catch_errors (do_captured_read_memory_integer, &args,
                         "", RETURN_MASK_ALL);
 
   status = catch_errors (do_captured_read_memory_integer, &args,
                         "", RETURN_MASK_ALL);


@@ -293,21 +309,21 @@ safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
 }
 
 LONGEST
 }
 
 LONGEST

-read_memory_integer (CORE_ADDR memaddr, int len)
+read_memory_integer (CORE_ADDR memaddr, int len, enum bfd_endian byte_order)

 {
 {

-  char buf[sizeof (LONGEST)];
+  gdb_byte buf[sizeof (LONGEST)];

 
   read_memory (memaddr, buf, len);
 
   read_memory (memaddr, buf, len);

-  return extract_signed_integer (buf, len);
+  return extract_signed_integer (buf, len, byte_order);

 }
 
 ULONGEST
 }
 
 ULONGEST

-read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
+read_memory_unsigned_integer (CORE_ADDR memaddr, int len, enum bfd_endian byte_order)

 {
 {

-  char buf[sizeof (ULONGEST)];
+  gdb_byte buf[sizeof (ULONGEST)];

 
   read_memory (memaddr, buf, len);
 
   read_memory (memaddr, buf, len);

-  return extract_unsigned_integer (buf, len);
+  return extract_unsigned_integer (buf, len, byte_order);

 }
 
 void
 }
 
 void


@@ -340,7 +356,8 @@ read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 CORE_ADDR
 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 {
 CORE_ADDR
 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 {

-  char *buf = alloca (TYPE_LENGTH (type));
+  gdb_byte *buf = alloca (TYPE_LENGTH (type));
+

   read_memory (addr, buf, TYPE_LENGTH (type));
   return extract_typed_address (buf, type);
 }
   read_memory (addr, buf, TYPE_LENGTH (type));
   return extract_typed_address (buf, type);
 }


@@ -350,65 +367,35 @@ void
 write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len)
 {
   int status;
 write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len)
 {
   int status;

-  bfd_byte *bytes = alloca (len);
-  
-  memcpy (bytes, myaddr, len);
-  status = target_write_memory (memaddr, bytes, len);
+
+  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
   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)
+write_memory_unsigned_integer (CORE_ADDR addr, int len, 
+                              enum bfd_endian byte_order,
+                              ULONGEST value)

 {
 {

-  char *buf = alloca (len);
-  store_unsigned_integer (buf, len, value);
-  write_memory (addr, buf, len);
-}
+  gdb_byte *buf = alloca (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);
+  store_unsigned_integer (buf, len, byte_order, value);

   write_memory (addr, buf, len);
 }
 
   write_memory (addr, buf, len);
 }
 

-\f
-
-#if 0
-/* Enable after 4.12.  It is not tested.  */
-
-/* Search code.  Targets can just make this their search function, or
-   if the protocol has a less general search function, they can call this
-   in the cases it can't handle.  */
+/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer.  */

 void
 void

-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)
+write_memory_signed_integer (CORE_ADDR addr, int len, 
+                            enum bfd_endian byte_order,
+                            LONGEST value)

 {
 {

-  int i;
-  CORE_ADDR curaddr = startaddr;
+  gdb_byte *buf = alloca (len);

 
 

-  while (curaddr >= lorange && curaddr < hirange)
-    {
-      read_memory (curaddr, data_found, len);
-      for (i = 0; i < len; ++i)
-       if ((data_found[i] & mask[i]) != data[i])
-         goto try_again;
-      /* It matches.  */
-      *addr_found = curaddr;
-      return;
-
-    try_again:
-      curaddr += increment;
-    }
-  *addr_found = (CORE_ADDR) 0;
-  return;
+  store_signed_integer (buf, len, byte_order, value);
+  write_memory (addr, buf, len);

 }
 }

-#endif /* 0 */

 \f
 /* The current default bfd target.  Points to storage allocated for
    gnutarget_string.  */
 \f
 /* The current default bfd target.  Points to storage allocated for
    gnutarget_string.  */


@@ -416,6 +403,12 @@ char *gnutarget;
 
 /* Same thing, except it is "auto" not NULL for the default case.  */
 static char *gnutarget_string;
 
 /* Same thing, except it is "auto" not NULL for the default case.  */
 static char *gnutarget_string;

+static void
+show_gnutarget_string (struct ui_file *file, int from_tty,
+                      struct cmd_list_element *c, const char *value)
+{
+  fprintf_filtered (file, _("The current BFD target is \"%s\".\n"), value);
+}

 
 static void set_gnutarget_command (char *, int, struct cmd_list_element *);
 
 
 static void set_gnutarget_command (char *, int, struct cmd_list_element *);
 


@@ -434,7 +427,7 @@ set_gnutarget (char *newtarget)
 {
   if (gnutarget_string != NULL)
     xfree (gnutarget_string);
 {
   if (gnutarget_string != NULL)
     xfree (gnutarget_string);

-  gnutarget_string = savestring (newtarget, strlen (newtarget));
+  gnutarget_string = xstrdup (newtarget);

   set_gnutarget_command (NULL, 0, NULL);
 }
 
   set_gnutarget_command (NULL, 0, NULL);
 }
 


@@ -442,19 +435,22 @@ void
 _initialize_core (void)
 {
   struct cmd_list_element *c;
 _initialize_core (void)
 {
   struct cmd_list_element *c;

-  c = add_cmd ("core-file", class_files, core_file_command,
-              "Use FILE as core dump for examining memory and registers.\n\
+
+  c = add_cmd ("core-file", class_files, core_file_command, _("\
+Use FILE as core dump for examining memory and registers.\n\

 No arg means have no core file.  This command has been superseded by the\n\
 No arg means have no core file.  This command has been superseded by the\n\

-`target core' and `detach' commands.", &cmdlist);
+`target core' and `detach' commands."), &cmdlist);

   set_cmd_completer (c, filename_completer);
 
   set_cmd_completer (c, filename_completer);
 

-  c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
-                  (char *) &gnutarget_string,
-                  "Set the current BFD target.\n\
-Use `set gnutarget auto' to specify automatic detection.",
-                  &setlist);
-  set_cmd_sfunc (c, set_gnutarget_command);
-  deprecated_add_show_from_set (c, &showlist);
+  
+  add_setshow_string_noescape_cmd ("gnutarget", class_files,
+                                  &gnutarget_string, _("\
+Set the current BFD target."), _("\
+Show the current BFD target."), _("\
+Use `set gnutarget auto' to specify automatic detection."),
+                                  set_gnutarget_command,
+                                  show_gnutarget_string,
+                                  &setlist, &showlist);

 
   if (getenv ("GNUTARGET"))
     set_gnutarget (getenv ("GNUTARGET"));
 
   if (getenv ("GNUTARGET"))
     set_gnutarget (getenv ("GNUTARGET"));