make MSYMBOL_VALUE_ADDRESS an rvalue

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

diff --git a/gdb/corefile.c b/gdb/corefile.c
index 345df90799efe426477a8ea2dddae2126f95538b..8a96d75db23e4b8a5989ae6fa1c8494194f7ac5d 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"
@@ -194,7 +194,7 @@ Use the \"file\" or \"exec-file\" command."));
 \f
 
 char *
-memory_error_message (enum target_xfer_error err,
+memory_error_message (enum target_xfer_status err,
                      struct gdbarch *gdbarch, CORE_ADDR memaddr)
 {
   switch (err)
@@ -204,13 +204,13 @@ memory_error_message (enum target_xfer_error err,
         bounds.  */
       return xstrprintf (_("Cannot access memory at address %s"),
                         paddress (gdbarch, memaddr));
-    case TARGET_XFER_E_UNAVAILABLE:
+    case TARGET_XFER_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),
+                     "unhandled target_xfer_status: %s (%s)",
+                     target_xfer_status_to_string (err),
                      plongest (err));
     }
 }
@@ -218,9 +218,10 @@ memory_error_message (enum target_xfer_error err,
 /* Report a memory error by throwing a suitable exception.  */
 
 void
-memory_error (enum target_xfer_error err, CORE_ADDR memaddr)
+memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
 {
   char *str;
+  enum errors exception = GDB_NO_ERROR;
 
   /* Build error string.  */
   str = memory_error_message (err, target_gdbarch (), memaddr);
@@ -230,15 +231,15 @@ memory_error (enum target_xfer_error err, CORE_ADDR memaddr)
   switch (err)
     {
     case TARGET_XFER_E_IO:
-      err = MEMORY_ERROR;
+      exception = MEMORY_ERROR;
       break;
-    case TARGET_XFER_E_UNAVAILABLE:
-      err = NOT_AVAILABLE_ERROR;
+    case TARGET_XFER_UNAVAILABLE:
+      exception = NOT_AVAILABLE_ERROR;
       break;
     }
 
   /* Throw it.  */
-  throw_error (err, ("%s"), str);
+  throw_error (exception, ("%s"), str);
 }
 
 /* Same as target_read_memory, but report an error if can't read.  */
@@ -246,20 +247,24 @@ memory_error (enum target_xfer_error err, CORE_ADDR memaddr)
 void
 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 {
-  LONGEST xfered = 0;
+  ULONGEST xfered = 0;
 
   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;
+      enum target_xfer_status status;
+      ULONGEST xfered_len;
+
+      status = target_xfer_partial (current_target.beneath,
+                                   TARGET_OBJECT_MEMORY, 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;
     }
 }
@@ -276,6 +281,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
@@ -354,6 +371,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)
 {