ALPHA: Migrate from 'regset_from_core_section' to 'iterate_over_regset_sections'

[deliverable/binutils-gdb.git] / gdb / ia64-hpux-nat.c

diff --git a/gdb/ia64-hpux-nat.c b/gdb/ia64-hpux-nat.c
index 48aa6de19ecad225f7c261fed3d3bf2fca54916f..6a4e088c5f0c784507f5eb1a6f5d705b818d4676 100644 (file)
--- a/gdb/ia64-hpux-nat.c
+++ b/gdb/ia64-hpux-nat.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2013 Free Software Foundation, Inc.
+/* Copyright (C) 2010-2014 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -342,10 +342,11 @@ static target_xfer_partial_ftype *super_xfer_partial;
 /* The "xfer_partial" routine for a memory region that is completely
    outside of the backing-store region.  */
 
-static LONGEST
+static enum target_xfer_status
 ia64_hpux_xfer_memory_no_bs (struct target_ops *ops, const char *annex,
                             gdb_byte *readbuf, const gdb_byte *writebuf,
-                            CORE_ADDR addr, LONGEST len)
+                            CORE_ADDR addr, LONGEST len,
+                            ULONGEST *xfered_len)
 {
   /* Memory writes need to be aligned on 16byte boundaries, at least
      when writing in the text section.  On the other hand, the size
@@ -367,17 +368,17 @@ ia64_hpux_xfer_memory_no_bs (struct target_ops *ops, const char *annex,
                                   NULL /* write */,
                                   aligned_addr, addr - aligned_addr);
       if (status <= 0)
-       return 0;
+       return TARGET_XFER_EOF;
       memcpy (aligned_buf + (addr - aligned_addr), writebuf, len);
 
       return super_xfer_partial (ops, TARGET_OBJECT_MEMORY, annex,
                                 NULL /* read */, aligned_buf /* write */,
-                                aligned_addr, aligned_len);
+                                aligned_addr, aligned_len, xfered_len);
     }
   else
     /* Memory read or properly aligned memory write.  */
     return super_xfer_partial (ops, TARGET_OBJECT_MEMORY, annex, readbuf,
-                              writebuf, addr, len);
+                              writebuf, addr, len, xfered_len);
 }
 
 /* Read LEN bytes at ADDR from memory, and store it in BUF.  This memory
@@ -517,10 +518,10 @@ ia64_hpux_get_register_from_save_state_t (int regnum, int reg_size)
 /* The "xfer_partial" target_ops routine for ia64-hpux, in the case
    where the requested object is TARGET_OBJECT_MEMORY.  */
 
-static LONGEST
+static enum target_xfer_status
 ia64_hpux_xfer_memory (struct target_ops *ops, const char *annex,
                       gdb_byte *readbuf, const gdb_byte *writebuf,
-                      CORE_ADDR addr, LONGEST len)
+                      CORE_ADDR addr, ULONGEST len, ULONGEST *xfered_len)
 {
   CORE_ADDR bsp, bspstore;
   CORE_ADDR start_addr, short_len;
@@ -563,7 +564,7 @@ ia64_hpux_xfer_memory (struct target_ops *ops, const char *annex,
       status = ia64_hpux_xfer_memory_no_bs (ops, annex, readbuf, writebuf,
                                            addr, short_len);
       if (status <= 0)
-        return 0;
+        return TARGET_XFER_EOF;
     }
 
   /* 2. Memory region after BSP.  */
@@ -581,7 +582,7 @@ ia64_hpux_xfer_memory (struct target_ops *ops, const char *annex,
                 writebuf ? writebuf + (start_addr - addr) : NULL,
                 start_addr, short_len);
       if (status <= 0)
-       return 0;
+       return TARGET_XFER_EOF;
     }
 
   /* 3. Memory region between BSPSTORE and BSP.  */
@@ -606,10 +607,11 @@ ia64_hpux_xfer_memory (struct target_ops *ops, const char *annex,
                  writebuf ? writebuf + (start_addr - addr) : NULL,
                  start_addr, short_len);
       if (status < 0)
-       return 0;
+       return TARGET_XFER_EOF;
     }
 
-  return len;
+  *xfered_len = len;
+  return TARGET_XFER_OK;
 }
 
 /* Handle the transfer of TARGET_OBJECT_HPUX_UREGS objects on ia64-hpux.
@@ -619,10 +621,10 @@ ia64_hpux_xfer_memory (struct target_ops *ops, const char *annex,
    we do not currently do not need these transfers), and will raise
    a failed assertion if WRITEBUF is not NULL.  */
 
-static LONGEST
+static enum target_xfer_status
 ia64_hpux_xfer_uregs (struct target_ops *ops, const char *annex,
                      gdb_byte *readbuf, const gdb_byte *writebuf,
-                     ULONGEST offset, LONGEST len)
+                     ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 {
   int status;
 
@@ -630,8 +632,10 @@ ia64_hpux_xfer_uregs (struct target_ops *ops, const char *annex,
 
   status = ia64_hpux_read_register_from_save_state_t (offset, readbuf, len);
   if (status < 0)
-    return -1;
-  return len;
+    return TARGET_XFER_E_IO;
+
+  *xfered_len = (ULONGEST) len;
+  return TARGET_XFER_OK;
 }
 
 /* Handle the transfer of TARGET_OBJECT_HPUX_SOLIB_GOT objects on ia64-hpux.
@@ -640,10 +644,10 @@ ia64_hpux_xfer_uregs (struct target_ops *ops, const char *annex,
    we do not currently do not need these transfers), and will raise
    a failed assertion if WRITEBUF is not NULL.  */
 
-static LONGEST
+static enum target_xfer_status
 ia64_hpux_xfer_solib_got (struct target_ops *ops, const char *annex,
                          gdb_byte *readbuf, const gdb_byte *writebuf,
-                         ULONGEST offset, LONGEST len)
+                         ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 {
   CORE_ADDR fun_addr;
   /* The linkage pointer.  We use a uint64_t to make sure that the size
@@ -656,7 +660,7 @@ ia64_hpux_xfer_solib_got (struct target_ops *ops, const char *annex,
   gdb_assert (writebuf == NULL);
 
   if (offset > sizeof (got))
-    return 0;
+    return TARGET_XFER_EOF;
 
   fun_addr = string_to_core_addr (annex);
   got = ia64_hpux_get_solib_linkage_addr (fun_addr);
@@ -665,28 +669,32 @@ ia64_hpux_xfer_solib_got (struct target_ops *ops, const char *annex,
     len = sizeof (got) - offset;
   memcpy (readbuf, &got + offset, len);
 
-  return len;
+  *xfered_len = (ULONGEST) len;
+  return TARGET_XFER_OK;
 }
 
 /* The "to_xfer_partial" target_ops routine for ia64-hpux.  */
 
-static LONGEST
+static enum target_xfer_status
 ia64_hpux_xfer_partial (struct target_ops *ops, enum target_object object,
                        const char *annex, gdb_byte *readbuf,
-                       const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
+                       const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+                       ULONGEST *xfered_len)
 {
-  LONGEST val;
+  enum target_xfer_status val;
 
   if (object == TARGET_OBJECT_MEMORY)
-    val = ia64_hpux_xfer_memory (ops, annex, readbuf, writebuf, offset, len);
+    val = ia64_hpux_xfer_memory (ops, annex, readbuf, writebuf, offset, len,
+                                xfered_len);
   else if (object == TARGET_OBJECT_HPUX_UREGS)
-    val = ia64_hpux_xfer_uregs (ops, annex, readbuf, writebuf, offset, len);
+    val = ia64_hpux_xfer_uregs (ops, annex, readbuf, writebuf, offset, len,
+                               xfered_len);
   else if (object == TARGET_OBJECT_HPUX_SOLIB_GOT)
     val = ia64_hpux_xfer_solib_got (ops, annex, readbuf, writebuf, offset,
-                                   len);
+                                   len, xfered_len);
   else
     val = super_xfer_partial (ops, object, annex, readbuf, writebuf, offset,
-                             len);
+                             len, xfered_len);
 
   return val;
 }
@@ -694,7 +702,8 @@ ia64_hpux_xfer_partial (struct target_ops *ops, enum target_object object,
 /* The "to_can_use_hw_breakpoint" target_ops routine for ia64-hpux.  */
 
 static int
-ia64_hpux_can_use_hw_breakpoint (int type, int cnt, int othertype)
+ia64_hpux_can_use_hw_breakpoint (struct target_ops *self,
+                                int type, int cnt, int othertype)
 {
   /* No hardware watchpoint/breakpoint support yet.  */
   return 0;