* config.guess: Update to version 2011-02-02

[deliverable/binutils-gdb.git] / gdb / spu-linux-nat.c

diff --git a/gdb/spu-linux-nat.c b/gdb/spu-linux-nat.c
index 3fbc9a1d8db35e4fb854aed2608179cea9229080..db47292228fe77c40865537ddc509612a657f481 100644 (file)
--- a/gdb/spu-linux-nat.c
+++ b/gdb/spu-linux-nat.c
@@ -1,5 +1,6 @@
 /* SPU native-dependent code for GDB, the GNU debugger.
 /* SPU native-dependent code for GDB, the GNU debugger.

-   Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
+   Free Software Foundation, Inc.

 
    Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
 
 
    Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
 


@@ -7,7 +8,7 @@
 
    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 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., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "gdbcore.h"
 
 #include "defs.h"
 #include "gdbcore.h"


@@ -29,6 +28,7 @@
 #include "regcache.h"
 #include "symfile.h"
 #include "gdb_wait.h"
 #include "regcache.h"
 #include "symfile.h"
 #include "gdb_wait.h"

+#include "gdbthread.h"

 
 #include <sys/ptrace.h>
 #include <asm/ptrace.h>
 
 #include <sys/ptrace.h>
 #include <asm/ptrace.h>


@@ -67,7 +67,7 @@ fetch_ppc_register (int regno)
       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
              (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
     if (errno == 0)
       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
              (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
     if (errno == 0)

-      return (ULONGEST) *(unsigned long long *)buf;
+      return (ULONGEST) *(uint64_t *)buf;

   }
 #endif
 
   }
 #endif
 


@@ -93,7 +93,7 @@ fetch_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
 #ifndef __powerpc64__
   if (memaddr >> 32)
     {
 #ifndef __powerpc64__
   if (memaddr >> 32)
     {

-      unsigned long long addr_8 = (unsigned long long) memaddr;
+      uint64_t addr_8 = (uint64_t) memaddr;

       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
     }
   else
       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
     }
   else


@@ -112,7 +112,7 @@ store_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
 #ifndef __powerpc64__
   if (memaddr >> 32)
     {
 #ifndef __powerpc64__
   if (memaddr >> 32)
     {

-      unsigned long long addr_8 = (unsigned long long) memaddr;
+      uint64_t addr_8 = (uint64_t) memaddr;

       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
     }
   else
       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
     }
   else


@@ -139,8 +139,11 @@ fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
 
   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 
   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))

-    if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
-      return ret;
+    {
+      ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
+      if (ret)
+       return ret;
+    }

 
   memcpy (myaddr,
          (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 
   memcpy (myaddr,
          (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),


@@ -167,21 +170,30 @@ store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 
   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 
   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))

-    if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
-      return ret;
+    {
+      ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
+      if (ret)
+       return ret;
+    }

 
   if (count > 1)
 
   if (count > 1)

-    if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
+    {
+      ret = fetch_ppc_memory_1 (tid, addr + (count - 1)

                                               * sizeof (PTRACE_TYPE_RET),
                                               * sizeof (PTRACE_TYPE_RET),

-                                  &buffer[count - 1])) != 0)
-      return ret;
+                               &buffer[count - 1]);
+      if (ret)
+       return ret;
+    }

 
   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
           myaddr, len);
 
   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 
   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
           myaddr, len);
 
   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))

-    if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
-      return ret;
+    {
+      ret = store_ppc_memory_1 (tid, addr, buffer[i]);
+      if (ret)
+       return ret;
+    }

 
   return 0;
 }
 
   return 0;
 }


@@ -193,6 +205,7 @@ store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
 static int 
 parse_spufs_run (int *fd, ULONGEST *addr)
 {
 static int 
 parse_spufs_run (int *fd, ULONGEST *addr)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);

   gdb_byte buf[4];
   ULONGEST pc = fetch_ppc_register (32);  /* nip */
 
   gdb_byte buf[4];
   ULONGEST pc = fetch_ppc_register (32);  /* nip */
 


@@ -200,7 +213,7 @@ parse_spufs_run (int *fd, ULONGEST *addr)
   if (fetch_ppc_memory (pc-4, buf, 4) != 0)
     return 0;
   /* It should be a "sc" instruction.  */
   if (fetch_ppc_memory (pc-4, buf, 4) != 0)
     return 0;
   /* It should be a "sc" instruction.  */

-  if (extract_unsigned_integer (buf, 4) != INSTR_SC)
+  if (extract_unsigned_integer (buf, 4, byte_order) != INSTR_SC)

     return 0;
   /* System call number should be NR_spu_run.  */
   if (fetch_ppc_register (0) != NR_spu_run)
     return 0;
   /* System call number should be NR_spu_run.  */
   if (fetch_ppc_register (0) != NR_spu_run)


@@ -237,7 +250,7 @@ spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
     {
       close (fd);
       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
     {
       close (fd);

-      return -1;
+      return 0;

     }
 
   if (writebuf)
     }
 
   if (writebuf)


@@ -297,6 +310,7 @@ static bfd *
 spu_bfd_open (ULONGEST addr)
 {
   struct bfd *nbfd;
 spu_bfd_open (ULONGEST addr)
 {
   struct bfd *nbfd;

+  asection *spu_name;

 
   ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
   *open_closure = addr;
 
   ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
   *open_closure = addr;


@@ -314,6 +328,22 @@ spu_bfd_open (ULONGEST addr)
       return NULL;
     }
 
       return NULL;
     }
 

+  /* Retrieve SPU name note and update BFD name.  */
+  spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
+  if (spu_name)
+    {
+      int sect_size = bfd_section_size (nbfd, spu_name);
+      if (sect_size > 20)
+       {
+         char *buf = alloca (sect_size - 20 + 1);
+         bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
+         buf[sect_size - 20] = '\0';
+
+         xfree ((char *)nbfd->filename);
+         nbfd->filename = xstrdup (buf);
+       }
+    }
+

   return nbfd;
 }
 
   return nbfd;
 }
 


@@ -337,13 +367,15 @@ spu_symbol_file_add_from_memory (int inferior_fd)
   if (len <= 0 || len >= sizeof id)
     return;
   id[len] = 0;
   if (len <= 0 || len >= sizeof id)
     return;
   id[len] = 0;

-  if (sscanf (id, "0x%llx", &addr) != 1)
+  addr = strtoulst (id, NULL, 16);
+  if (!addr)

     return;
 
   /* Open BFD representing SPE executable and read its symbols.  */
   nbfd = spu_bfd_open (addr);
   if (nbfd)
     return;
 
   /* Open BFD representing SPE executable and read its symbols.  */
   nbfd = spu_bfd_open (addr);
   if (nbfd)

-    symbol_file_add_from_bfd (nbfd, 0, NULL, 1, 0);
+    symbol_file_add_from_bfd (nbfd, SYMFILE_VERBOSE | SYMFILE_MAINLINE,
+                              NULL, 0);

 }
 
 
 }
 
 


@@ -392,7 +424,8 @@ spu_child_post_attach (int pid)
 /* Wait for child PTID to do something.  Return id of the child,
    minus_one_ptid in case of error; store status into *OURSTATUS.  */
 static ptid_t
 /* Wait for child PTID to do something.  Return id of the child,
    minus_one_ptid in case of error; store status into *OURSTATUS.  */
 static ptid_t

-spu_child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+spu_child_wait (struct target_ops *ops,
+               ptid_t ptid, struct target_waitstatus *ourstatus, int options)

 {
   int save_errno;
   int status;
 {
   int save_errno;
   int status;


@@ -402,7 +435,6 @@ spu_child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
     {
       set_sigint_trap ();      /* Causes SIGINT to be passed on to the
                                   attached process.  */
     {
       set_sigint_trap ();      /* Causes SIGINT to be passed on to the
                                   attached process.  */

-      set_sigio_trap ();

 
       pid = waitpid (PIDGET (ptid), &status, 0);
       if (pid == -1 && errno == ECHILD)
 
       pid = waitpid (PIDGET (ptid), &status, 0);
       if (pid == -1 && errno == ECHILD)


@@ -419,20 +451,19 @@ spu_child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
          save_errno = EINTR;
        }
 
          save_errno = EINTR;
        }
 

-      clear_sigio_trap ();

       clear_sigint_trap ();
     }
   while (pid == -1 && save_errno == EINTR);
 
   if (pid == -1)
     {
       clear_sigint_trap ();
     }
   while (pid == -1 && save_errno == EINTR);
 
   if (pid == -1)
     {

-      warning ("Child process unexpectedly missing: %s",
+      warning (_("Child process unexpectedly missing: %s"),

               safe_strerror (save_errno));
 
       /* Claim it exited with unknown signal.  */
       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
               safe_strerror (save_errno));
 
       /* Claim it exited with unknown signal.  */
       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;

-      return minus_one_ptid;
+      return inferior_ptid;

     }
 
   store_waitstatus (ourstatus, status);
     }
 
   store_waitstatus (ourstatus, status);


@@ -441,7 +472,8 @@ spu_child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
 /* Override the fetch_inferior_register routine.  */
 static void
 
 /* Override the fetch_inferior_register routine.  */
 static void

-spu_fetch_inferior_registers (struct regcache *regcache, int regno)
+spu_fetch_inferior_registers (struct target_ops *ops,
+                             struct regcache *regcache, int regno)

 {
   int fd;
   ULONGEST addr;
 {
   int fd;
   ULONGEST addr;


@@ -453,8 +485,10 @@ spu_fetch_inferior_registers (struct regcache *regcache, int regno)
   /* The ID register holds the spufs file handle.  */
   if (regno == -1 || regno == SPU_ID_REGNUM)
     {
   /* The ID register holds the spufs file handle.  */
   if (regno == -1 || regno == SPU_ID_REGNUM)
     {

+      struct gdbarch *gdbarch = get_regcache_arch (regcache);
+      enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

       char buf[4];
       char buf[4];

-      store_unsigned_integer (buf, 4, fd);
+      store_unsigned_integer (buf, 4, byte_order, fd);

       regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
     }
 
       regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
     }
 


@@ -482,7 +516,8 @@ spu_fetch_inferior_registers (struct regcache *regcache, int regno)
 
 /* Override the store_inferior_register routine.  */
 static void
 
 /* Override the store_inferior_register routine.  */
 static void

-spu_store_inferior_registers (struct regcache *regcache, int regno)
+spu_store_inferior_registers (struct target_ops *ops,
+                             struct regcache *regcache, int regno)

 {
   int fd;
   ULONGEST addr;
 {
   int fd;
   ULONGEST addr;


@@ -521,11 +556,17 @@ spu_xfer_partial (struct target_ops *ops,
                  gdb_byte *readbuf, const gdb_byte *writebuf,
                  ULONGEST offset, LONGEST len)
 {
                  gdb_byte *readbuf, const gdb_byte *writebuf,
                  ULONGEST offset, LONGEST len)
 {

+  if (object == TARGET_OBJECT_SPU)
+    return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len);
+

   if (object == TARGET_OBJECT_MEMORY)
     {
       int fd;
       ULONGEST addr;
   if (object == TARGET_OBJECT_MEMORY)
     {
       int fd;
       ULONGEST addr;

-      char mem_annex[32];
+      char mem_annex[32], lslr_annex[32];
+      gdb_byte buf[32];
+      ULONGEST lslr;
+      LONGEST ret;

 
       /* We must be stopped on a spu_run system call.  */
       if (!parse_spufs_run (&fd, &addr))
 
       /* We must be stopped on a spu_run system call.  */
       if (!parse_spufs_run (&fd, &addr))


@@ -533,7 +574,22 @@ spu_xfer_partial (struct target_ops *ops,
 
       /* Use the "mem" spufs file to access SPU local store.  */
       xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
 
       /* Use the "mem" spufs file to access SPU local store.  */
       xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);

-      return spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
+      ret = spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
+      if (ret > 0)
+       return ret;
+
+      /* SPU local store access wraps the address around at the
+        local store limit.  We emulate this here.  To avoid needing
+        an extra access to retrieve the LSLR, we only do that after
+        trying the original address first, and getting end-of-file.  */
+      xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
+      memset (buf, 0, sizeof buf);
+      if (spu_proc_xfer_spu (lslr_annex, buf, NULL, 0, sizeof buf) <= 0)
+       return ret;
+
+      lslr = strtoulst (buf, NULL, 16);
+      return spu_proc_xfer_spu (mem_annex, readbuf, writebuf,
+                               offset & lslr, len);

     }
 
   return -1;
     }
 
   return -1;


@@ -567,4 +623,3 @@ _initialize_spu_nat (void)
   /* Register SPU target.  */
   add_target (t);
 }
   /* Register SPU target.  */
   add_target (t);
 }

-