X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fcorefile.c;h=6cc2afc49e816e2dbefe45266e2977df1a5e4176;hb=a31d2f068fa1384c505b540ea595d2d97813ba5f;hp=af2d1a3633b9e14be46aecd2039d775d2514c351;hpb=136d6dae62acd18254ced95f2ae6e6423bcda3c9;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/corefile.c b/gdb/corefile.c
index af2d1a3633..6cc2afc49e 100644
--- a/gdb/corefile.c
+++ b/gdb/corefile.c
@@ -1,7 +1,6 @@
 /* Core dump and executable file functions above target vector, for GDB.
 
-   Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
-   1999, 2000, 2001, 2003, 2006, 2007, 2008 Free Software Foundation, Inc.
+   Copyright (C) 1986-2016 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -19,8 +18,6 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
-#include "gdb_string.h"
-#include <errno.h>
 #include <signal.h>
 #include <fcntl.h>
 #include "inferior.h"
@@ -31,14 +28,14 @@
 #include "target.h"
 #include "gdbcore.h"
 #include "dis-asm.h"
-#include "gdb_stat.h"
+#include <sys/stat.h>
 #include "completer.h"
-#include "exceptions.h"
+#include "observer.h"
+#include "cli/cli-utils.h"
 
 /* Local function declarations.  */
 
 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
@@ -49,15 +46,20 @@ static void call_extra_exec_file_hooks (char *filename);
    only one hook could be set, and which called
    deprecated_exec_file_display_hook directly.  */
 
-typedef void (*hook_type) (char *);
+typedef void (*hook_type) (const char *);
 
-hook_type deprecated_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 */
+hook_type deprecated_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.  */
 
 /* Binary file diddling handle for the core file.  */
 
 bfd *core_bfd = NULL;
+
+/* corelow.c target.  It is never NULL after GDB initialization.  */
+
+struct target_ops *core_target;
 
 
 /* Backward compatability with old way of specifying core files.  */
@@ -65,18 +67,14 @@ bfd *core_bfd = NULL;
 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)
-    error (_("GDB can't read core files on this machine."));
+  gdb_assert (core_target != NULL);
 
   if (!filename)
-    (t->to_detach) (t, filename, from_tty);
+    (core_target->to_detach) (core_target, filename, from_tty);
   else
-    (t->to_open) (filename, from_tty);
+    (core_target->to_open) (filename, from_tty);
 }
 
 
@@ -85,7 +83,7 @@ core_file_command (char *filename, int from_tty)
    functions.  */
 
 static void
-call_extra_exec_file_hooks (char *filename)
+call_extra_exec_file_hooks (const char *filename)
 {
   int i;
 
@@ -97,18 +95,19 @@ call_extra_exec_file_hooks (char *filename)
    This is called from the x-window display code.  */
 
 void
-specify_exec_file_hook (void (*hook) (char *))
+specify_exec_file_hook (void (*hook) (const char *))
 {
   hook_type *new_array;
 
   if (deprecated_exec_file_display_hook != NULL)
     {
       /* There's already a hook installed.  Arrange to have both it
-       * and the subsequent hooks called. */
+	 and the subsequent hooks called.  */
       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));
+	  /* If this is the first extra hook, initialize the hook
+	     array.  */
+	  exec_file_extra_hooks = XNEW (hook_type);
 	  exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
 	  deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
 	  exec_file_hook_count = 1;
@@ -118,9 +117,9 @@ specify_exec_file_hook (void (*hook) (char *))
          Yes, it's inefficient to grow it by one each time but since
          this is hardly ever called it's not a big deal.  */
       exec_file_hook_count++;
-      new_array =
-	(hook_type *) xrealloc (exec_file_extra_hooks,
-				exec_file_hook_count * sizeof (hook_type));
+      new_array = (hook_type *)
+	xrealloc (exec_file_extra_hooks,
+		  exec_file_hook_count * sizeof (hook_type));
       exec_file_extra_hooks = new_array;
       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
     }
@@ -128,38 +127,21 @@ specify_exec_file_hook (void (*hook) (char *))
     deprecated_exec_file_display_hook = hook;
 }
 
-/* The exec file must be closed before running an inferior.
-   If it is needed again after the inferior dies, it must
-   be reopened.  */
-
-void
-close_exec_file (void)
-{
-#if 0				/* FIXME */
-  if (exec_bfd)
-    bfd_tempclose (exec_bfd);
-#endif
-}
-
 void
 reopen_exec_file (void)
 {
-#if 0				/* FIXME */
-  if (exec_bfd)
-    bfd_reopen (exec_bfd);
-#else
   char *filename;
   int res;
   struct stat st;
-  long mtime;
+  struct cleanup *cleanups;
 
-  /* Don't do anything if there isn't an exec file. */
+  /* 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. */
+  /* If the timestamp of the exec file has changed, reopen it.  */
   filename = xstrdup (bfd_get_filename (exec_bfd));
-  make_cleanup (xfree, filename);
+  cleanups = make_cleanup (xfree, filename);
   res = stat (filename, &st);
 
   if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
@@ -169,7 +151,8 @@ reopen_exec_file (void)
        this stops GDB from holding the executable open after it
        exits.  */
     bfd_cache_close_all ();
-#endif
+
+  do_cleanups (cleanups);
 }
 
 /* If we have both a core file and an exec file,
@@ -194,8 +177,8 @@ validate_files (void)
 char *
 get_exec_file (int err)
 {
-  if (exec_bfd)
-    return bfd_get_filename (exec_bfd);
+  if (exec_filename)
+    return exec_filename;
   if (!err)
     return NULL;
 
@@ -205,70 +188,122 @@ Use the \"file\" or \"exec-file\" command."));
 }
 
 
-/* Report a memory error with error().  */
+char *
+memory_error_message (enum target_xfer_status err,
+		      struct gdbarch *gdbarch, CORE_ADDR memaddr)
+{
+  switch (err)
+    {
+    case TARGET_XFER_E_IO:
+      /* Actually, address between memaddr and memaddr + len was out of
+	 bounds.  */
+      return xstrprintf (_("Cannot access memory at address %s"),
+			 paddress (gdbarch, memaddr));
+    case TARGET_XFER_UNAVAILABLE:
+      return xstrprintf (_("Memory at address %s unavailable."),
+			 paddress (gdbarch, memaddr));
+    default:
+      internal_error (__FILE__, __LINE__,
+		      "unhandled target_xfer_status: %s (%s)",
+		      target_xfer_status_to_string (err),
+		      plongest (err));
+    }
+}
+
+/* Report a memory error by throwing a suitable exception.  */
 
 void
-memory_error (int status, CORE_ADDR memaddr)
+memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
 {
-  struct ui_file *tmp_stream = mem_fileopen ();
-  make_cleanup_ui_file_delete (tmp_stream);
+  char *str;
+  enum errors exception = GDB_NO_ERROR;
+
+  /* Build error string.  */
+  str = memory_error_message (err, target_gdbarch (), memaddr);
+  make_cleanup (xfree, str);
 
-  if (status == EIO)
+  /* Choose the right error to throw.  */
+  switch (err)
     {
-      /* Actually, address between memaddr and memaddr + len
-         was out of bounds. */
-      fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
-      fputs_filtered (paddress (memaddr), tmp_stream);
+    case TARGET_XFER_E_IO:
+      exception = MEMORY_ERROR;
+      break;
+    case TARGET_XFER_UNAVAILABLE:
+      exception = NOT_AVAILABLE_ERROR;
+      break;
     }
-  else
+
+  /* Throw it.  */
+  throw_error (exception, ("%s"), str);
+}
+
+/* Helper function.  */
+
+static void
+read_memory_object (enum target_object object, CORE_ADDR memaddr,
+		    gdb_byte *myaddr, ssize_t len)
+{
+  ULONGEST xfered = 0;
+
+  while (xfered < len)
     {
-      fprintf_filtered (tmp_stream, "Error accessing memory address ");
-      fputs_filtered (paddress (memaddr), tmp_stream);
-      fprintf_filtered (tmp_stream, ": %s.",
-		       safe_strerror (status));
-    }
+      enum target_xfer_status status;
+      ULONGEST xfered_len;
 
-  error_stream (tmp_stream);
+      status = target_xfer_partial (current_target.beneath,
+				    object, NULL,
+				    myaddr + xfered, NULL,
+				    memaddr + xfered, len - xfered,
+				    &xfered_len);
+
+      if (status != TARGET_XFER_OK)
+	memory_error (status == TARGET_XFER_EOF ? TARGET_XFER_E_IO : status,
+		      memaddr + xfered);
+
+      xfered += xfered_len;
+      QUIT;
+    }
 }
 
 /* Same as target_read_memory, but report an error if can't read.  */
+
 void
-read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 {
-  int status;
-  status = target_read_memory (memaddr, myaddr, len);
-  if (status != 0)
-    memory_error (status, memaddr);
+  read_memory_object (TARGET_OBJECT_MEMORY, memaddr, myaddr, len);
 }
 
-/* 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
-   successfully read from MEMADDR of length LEN.  */
+/* Same as target_read_stack, but report an error if can't read.  */
 
-struct captured_read_memory_integer_arguments
+void
+read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 {
-  CORE_ADDR memaddr;
-  int len;
-  LONGEST result;
-};
-
-/* Helper function for gdb_read_memory_integer().  DATA must be a
-   pointer to a captured_read_memory_integer_arguments struct. 
-   Return 1 if successful.  Note that the catch_errors() interface
-   will return 0 if an error occurred while reading memory.  This
-   choice of return code is so that we can distinguish between
-   success and failure.  */
-
-static int
-do_captured_read_memory_integer (void *data)
+  read_memory_object (TARGET_OBJECT_STACK_MEMORY, memaddr, myaddr, len);
+}
+
+/* Same as target_read_code, but report an error if can't read.  */
+
+void
+read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 {
-  struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
-  CORE_ADDR memaddr = args->memaddr;
-  int len = args->len;
+  read_memory_object (TARGET_OBJECT_CODE_MEMORY, memaddr, myaddr, len);
+}
 
-  args->result = read_memory_integer (memaddr, len);
+/* Read memory at MEMADDR of length LEN and put the contents in
+   RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
+   if successful.  */
+
+int
+safe_read_memory_integer (CORE_ADDR memaddr, int len, 
+			  enum bfd_endian byte_order,
+			  LONGEST *return_value)
+{
+  gdb_byte buf[sizeof (LONGEST)];
 
+  if (target_read_memory (memaddr, buf, len))
+    return 0;
+
+  *return_value = extract_signed_integer (buf, len, byte_order);
   return 1;
 }
 
@@ -277,37 +312,57 @@ do_captured_read_memory_integer (void *data)
    if successful.  */
 
 int
-safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
+safe_read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
+				   enum bfd_endian byte_order,
+				   ULONGEST *return_value)
 {
-  int status;
-  struct captured_read_memory_integer_arguments args;
-  args.memaddr = memaddr;
-  args.len = len;
+  gdb_byte buf[sizeof (ULONGEST)];
 
-  status = catch_errors (do_captured_read_memory_integer, &args,
-                        "", RETURN_MASK_ALL);
-  if (status)
-    *return_value = args.result;
+  if (target_read_memory (memaddr, buf, len))
+    return 0;
 
-  return status;
+  *return_value = extract_unsigned_integer (buf, len, byte_order);
+  return 1;
 }
 
 LONGEST
-read_memory_integer (CORE_ADDR memaddr, int len)
+read_memory_integer (CORE_ADDR memaddr, int len,
+		     enum bfd_endian byte_order)
 {
   gdb_byte buf[sizeof (LONGEST)];
 
   read_memory (memaddr, buf, len);
-  return extract_signed_integer (buf, len);
+  return extract_signed_integer (buf, len, byte_order);
 }
 
 ULONGEST
-read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
+read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
+			      enum bfd_endian byte_order)
 {
   gdb_byte buf[sizeof (ULONGEST)];
 
   read_memory (memaddr, buf, len);
-  return extract_unsigned_integer (buf, len);
+  return extract_unsigned_integer (buf, len, byte_order);
+}
+
+LONGEST
+read_code_integer (CORE_ADDR memaddr, int len,
+		   enum bfd_endian byte_order)
+{
+  gdb_byte buf[sizeof (LONGEST)];
+
+  read_code (memaddr, buf, len);
+  return extract_signed_integer (buf, len, byte_order);
+}
+
+ULONGEST
+read_code_unsigned_integer (CORE_ADDR memaddr, int len,
+			    enum bfd_endian byte_order)
+{
+  gdb_byte buf[sizeof (ULONGEST)];
+
+  read_code (memaddr, buf, len);
+  return extract_unsigned_integer (buf, len, byte_order);
 }
 
 void
@@ -328,7 +383,7 @@ read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
       cnt = max_len - (cp - buffer);
       if (cnt > 8)
 	cnt = 8;
-      read_memory (memaddr + (int) (cp - buffer), cp, cnt);
+      read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
       for (i = 0; i < cnt && *cp; i++, cp++)
 	;			/* null body */
 
@@ -340,72 +395,60 @@ read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 CORE_ADDR
 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 {
-  gdb_byte *buf = alloca (TYPE_LENGTH (type));
+  gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
+
   read_memory (addr, buf, TYPE_LENGTH (type));
   return extract_typed_address (buf, type);
 }
 
-/* Same as target_write_memory, but report an error if can't write.  */
+/* See gdbcore.h.  */
+
 void
-write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len)
+write_memory (CORE_ADDR memaddr, 
+	      const bfd_byte *myaddr, ssize_t len)
 {
   int status;
+
   status = target_write_memory (memaddr, myaddr, len);
   if (status != 0)
-    memory_error (status, memaddr);
+    memory_error (TARGET_XFER_E_IO, memaddr);
 }
 
-/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer.  */
+/* Same as write_memory, but notify 'memory_changed' observers.  */
+
 void
-write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value)
+write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
+				ssize_t len)
 {
-  gdb_byte *buf = alloca (len);
-  store_unsigned_integer (buf, len, value);
-  write_memory (addr, buf, len);
+  write_memory (memaddr, myaddr, len);
+  observer_notify_memory_changed (current_inferior (), memaddr, len, myaddr);
 }
 
-/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer.  */
+/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
+   integer.  */
 void
-write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value)
+write_memory_unsigned_integer (CORE_ADDR addr, int len, 
+			       enum bfd_endian byte_order,
+			       ULONGEST value)
 {
-  gdb_byte *buf = alloca (len);
-  store_signed_integer (buf, len, value);
+  gdb_byte *buf = (gdb_byte *) alloca (len);
+
+  store_unsigned_integer (buf, len, byte_order, value);
   write_memory (addr, buf, len);
 }
 
-
-
-#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
-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 = (gdb_byte *) 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 */
 
 /* The current default bfd target.  Points to storage allocated for
    gnutarget_string.  */
@@ -415,29 +458,62 @@ char *gnutarget;
 static char *gnutarget_string;
 static void
 show_gnutarget_string (struct ui_file *file, int from_tty,
-		       struct cmd_list_element *c, const char *value)
+		       struct cmd_list_element *c,
+		       const char *value)
 {
-  fprintf_filtered (file, _("The current BFD target is \"%s\".\n"), 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 *);
 
 static void
-set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
+set_gnutarget_command (char *ignore, int from_tty,
+		       struct cmd_list_element *c)
 {
+  char *gend = gnutarget_string + strlen (gnutarget_string);
+
+  gend = remove_trailing_whitespace (gnutarget_string, gend);
+  *gend = '\0';
+
   if (strcmp (gnutarget_string, "auto") == 0)
     gnutarget = NULL;
   else
     gnutarget = gnutarget_string;
 }
 
+/* A completion function for "set gnutarget".  */
+
+static VEC (char_ptr) *
+complete_set_gnutarget (struct cmd_list_element *cmd,
+			const char *text, const char *word)
+{
+  static const char **bfd_targets;
+
+  if (bfd_targets == NULL)
+    {
+      int last;
+
+      bfd_targets = bfd_target_list ();
+      for (last = 0; bfd_targets[last] != NULL; ++last)
+	;
+
+      bfd_targets = XRESIZEVEC (const char *, bfd_targets, last + 2);
+      bfd_targets[last] = "auto";
+      bfd_targets[last + 1] = NULL;
+    }
+
+  return complete_on_enum (bfd_targets, text, word);
+}
+
 /* Set the gnutarget.  */
 void
 set_gnutarget (char *newtarget)
 {
   if (gnutarget_string != NULL)
     xfree (gnutarget_string);
-  gnutarget_string = savestring (newtarget, strlen (newtarget));
+  gnutarget_string = xstrdup (newtarget);
   set_gnutarget_command (NULL, 0, NULL);
 }
 
@@ -445,6 +521,7 @@ void
 _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\
 No arg means have no core file.  This command has been superseded by the\n\
@@ -452,14 +529,17 @@ No arg means have no core file.  This command has been superseded by the\n\
   set_cmd_completer (c, filename_completer);
 
   
-  add_setshow_string_noescape_cmd ("gnutarget", class_files,
-				   &gnutarget_string, _("\
+  c = 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);
+				       set_gnutarget_command,
+				       show_gnutarget_string,
+				       &setlist, &showlist);
+  set_cmd_completer (c, complete_set_gnutarget);
+
+  add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
 
   if (getenv ("GNUTARGET"))
     set_gnutarget (getenv ("GNUTARGET"));