Extract string-printing out of ada_val_print_array

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

diff --git a/gdb/corefile.c b/gdb/corefile.c
index a86f4b335e2daed721aa443c03491324b63fdbb9..1ed8395c6b893a9f466959be8e773e504460d51d 100644 (file)
--- a/gdb/corefile.c
+++ b/gdb/corefile.c
@@ -1,6 +1,6 @@
 /* Core dump and executable file functions above target vector, for GDB.
 
-   Copyright (C) 1986-2013 Free Software Foundation, Inc.
+   Copyright (C) 1986-2014 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -18,7 +18,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
-#include "gdb_string.h"
+#include <string.h>
 #include <errno.h>
 #include <signal.h>
 #include <fcntl.h>
@@ -30,7 +30,7 @@
 #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"
@@ -182,8 +182,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;
 
@@ -193,22 +193,52 @@ Use the \"file\" or \"exec-file\" command."));
 }
 \f
 
-/* Report a memory error by throwing a MEMORY_ERROR error.  */
+char *
+memory_error_message (enum target_xfer_error 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_E_UNAVAILABLE:
+      return xstrprintf (_("Memory at address %s unavailable."),
+                        paddress (gdbarch, memaddr));
+    default:
+      internal_error (__FILE__, __LINE__,
+                     "unhandled target_xfer_error: %s (%s)",
+                     target_xfer_error_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_error err, CORE_ADDR memaddr)
 {
-  if (status == EIO)
-    /* 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
-    throw_error (MEMORY_ERROR,
-                _("Error accessing memory address %s: %s."),
-                paddress (target_gdbarch (), memaddr),
-                safe_strerror (status));
+  char *str;
+
+  /* Build error string.  */
+  str = memory_error_message (err, target_gdbarch (), memaddr);
+  make_cleanup (xfree, str);
+
+  /* Choose the right error to throw.  */
+  switch (err)
+    {
+    case TARGET_XFER_E_IO:
+      err = MEMORY_ERROR;
+      break;
+    case TARGET_XFER_E_UNAVAILABLE:
+      err = NOT_AVAILABLE_ERROR;
+      break;
+    }
+
+  /* Throw it.  */
+  throw_error (err, ("%s"), str);
 }
 
 /* Same as target_read_memory, but report an error if can't read.  */
@@ -216,11 +246,22 @@ memory_error (int status, CORE_ADDR memaddr)
 void
 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 {
-  int status;
+  LONGEST xfered = 0;
 
-  status = target_read_memory (memaddr, myaddr, len);
-  if (status != 0)
-    memory_error (status, memaddr);
+  while (xfered < len)
+    {
+      LONGEST xfer = target_xfer_partial (current_target.beneath,
+                                         TARGET_OBJECT_MEMORY, NULL,
+                                         myaddr + xfered, NULL,
+                                         memaddr + xfered, len - xfered);
+
+      if (xfer == 0)
+       memory_error (TARGET_XFER_E_IO, memaddr + xfered);
+      if (xfer < 0)
+       memory_error (xfer, memaddr + xfered);
+      xfered += xfer;
+      QUIT;
+    }
 }
 
 /* Same as target_read_stack, but report an error if can't read.  */
@@ -235,6 +276,18 @@ read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
     memory_error (status, memaddr);
 }
 
+/* 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)
+{
+  int status;
+
+  status = target_read_code (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
@@ -313,6 +366,26 @@ read_memory_unsigned_integer (CORE_ADDR memaddr, int 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
 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 {