* linux-low.c (linux_prepare_to_access_memory): New.

[deliverable/binutils-gdb.git] / gdb / gdbserver / spu-low.c

diff --git a/gdb/gdbserver/spu-low.c b/gdb/gdbserver/spu-low.c
index 024a0525ec63f213c4ac379ce6c131c7c3b6280c..dc301b2ed164d05abef150e03cd450c643c0618c 100644 (file)
--- a/gdb/gdbserver/spu-low.c
+++ b/gdb/gdbserver/spu-low.c
@@ -1,5 +1,5 @@
 /* Low level interface to SPUs, for the remote server for GDB.
 /* Low level interface to SPUs, for the remote server for GDB.

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

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


@@ -7,7 +7,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 +16,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 "server.h"
 
 
 #include "server.h"
 


@@ -35,7 +33,7 @@
 /* Some older glibc versions do not define this.  */
 #ifndef __WNOTHREAD
 #define __WNOTHREAD     0x20000000      /* Don't wait on children of other
 /* Some older glibc versions do not define this.  */
 #ifndef __WNOTHREAD
 #define __WNOTHREAD     0x20000000      /* Don't wait on children of other

-                                          threads in this group */
+                                          threads in this group */

 #endif
 
 #define PTRACE_TYPE_RET long
 #endif
 
 #define PTRACE_TYPE_RET long


@@ -54,11 +52,13 @@
 #define NR_spu_run     0x0116
 
 /* Get current thread ID (Linux task ID).  */
 #define NR_spu_run     0x0116
 
 /* Get current thread ID (Linux task ID).  */

-#define current_tid ((struct inferior_list_entry *)current_inferior)->id
+#define current_ptid ((struct inferior_list_entry *)current_inferior)->id

 
 /* These are used in remote-utils.c.  */
 int using_threads = 0;
 
 /* These are used in remote-utils.c.  */
 int using_threads = 0;

-int debug_threads = 0;
+
+/* Defined in auto-generated file reg-spu.c.  */
+void init_registers_spu (void);

 
 
 /* Fetch PPU register REGNO.  */
 
 
 /* Fetch PPU register REGNO.  */


@@ -67,7 +67,7 @@ fetch_ppc_register (int regno)
 {
   PTRACE_TYPE_RET res;
 
 {
   PTRACE_TYPE_RET res;
 

-  int tid = current_tid;
+  int tid = ptid_get_lwp (current_ptid);

 
 #ifndef __powerpc64__
   /* If running as a 32-bit process on a 64-bit system, we attempt
 
 #ifndef __powerpc64__
   /* If running as a 32-bit process on a 64-bit system, we attempt


@@ -90,7 +90,7 @@ fetch_ppc_register (int regno)
 
   errno = 0;
   res = ptrace (PT_READ_U, tid,
 
   errno = 0;
   res = ptrace (PT_READ_U, tid,

-               (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
+               (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);

   if (errno != 0)
     {
       char mess[128];
   if (errno != 0)
     {
       char mess[128];


@@ -150,7 +150,7 @@ fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
               / sizeof (PTRACE_TYPE_RET));
   PTRACE_TYPE_RET *buffer;
 
               / sizeof (PTRACE_TYPE_RET));
   PTRACE_TYPE_RET *buffer;
 

-  int tid = current_tid;
+  int tid = ptid_get_lwp (current_ptid);

 
   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))


@@ -175,7 +175,7 @@ store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
               / sizeof (PTRACE_TYPE_RET));
   PTRACE_TYPE_RET *buffer;
 
               / sizeof (PTRACE_TYPE_RET));
   PTRACE_TYPE_RET *buffer;
 

-  int tid = current_tid;
+  int tid = ptid_get_lwp (current_ptid);

 
   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 
 
   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 


@@ -190,7 +190,7 @@ store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
       return ret;
 
   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
       return ret;
 
   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),

-          myaddr, len);
+         myaddr, len);

 
   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
     if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
 
   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
     if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)


@@ -203,7 +203,7 @@ store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 /* If the PPU thread is currently stopped on a spu_run system call,
    return to FD and ADDR the file handle and NPC parameter address
    used with the system call.  Return non-zero if successful.  */
 /* If the PPU thread is currently stopped on a spu_run system call,
    return to FD and ADDR the file handle and NPC parameter address
    used with the system call.  Return non-zero if successful.  */

-static int 
+static int

 parse_spufs_run (int *fd, CORE_ADDR *addr)
 {
   char buf[4];
 parse_spufs_run (int *fd, CORE_ADDR *addr)
 {
   char buf[4];


@@ -240,7 +240,7 @@ spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
   if (!annex)
     return 0;
 
   if (!annex)
     return 0;
 

-  sprintf (buf, "/proc/%ld/fd/%s", current_tid, annex);
+  sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);

   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
   if (fd <= 0)
     return -1;
   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
   if (fd <= 0)
     return -1;


@@ -249,7 +249,7 @@ spu_proc_xfer_spu (const char *annex, unsigned char *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)


@@ -268,6 +268,7 @@ static int
 spu_create_inferior (char *program, char **allargs)
 {
   int pid;
 spu_create_inferior (char *program, char **allargs)
 {
   int pid;

+  ptid_t ptid;

 
   pid = fork ();
   if (pid < 0)
 
   pid = fork ();
   if (pid < 0)


@@ -280,6 +281,8 @@ spu_create_inferior (char *program, char **allargs)
       setpgid (0, 0);
 
       execv (program, allargs);
       setpgid (0, 0);
 
       execv (program, allargs);

+      if (errno == ENOENT)
+       execvp (program, allargs);

 
       fprintf (stderr, "Cannot exec %s: %s.\n", program,
               strerror (errno));
 
       fprintf (stderr, "Cannot exec %s: %s.\n", program,
               strerror (errno));


@@ -287,7 +290,10 @@ spu_create_inferior (char *program, char **allargs)
       _exit (0177);
     }
 
       _exit (0177);
     }
 

-  add_thread (pid, NULL, pid);
+  add_process (pid, 0);
+
+  ptid = ptid_build (pid, pid, 0);
+  add_thread (ptid, NULL);

   return pid;
 }
 
   return pid;
 }
 


@@ -295,6 +301,8 @@ spu_create_inferior (char *program, char **allargs)
 int
 spu_attach (unsigned long  pid)
 {
 int
 spu_attach (unsigned long  pid)
 {

+  ptid_t ptid;
+

   if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
     {
       fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
   if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
     {
       fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,


@@ -303,72 +311,117 @@ spu_attach (unsigned long  pid)
       _exit (0177);
     }
 
       _exit (0177);
     }
 

-  add_thread (pid, NULL, pid);
+  add_process (pid, 1);
+  ptid = ptid_build (pid, pid, 0);
+  add_thread (ptid, NULL);

   return 0;
 }
 
 /* Kill the inferior process.  */
   return 0;
 }
 
 /* Kill the inferior process.  */

-static void
-spu_kill (void)
+static int
+spu_kill (int pid)

 {
 {

-  ptrace (PTRACE_KILL, current_tid, 0, 0);
+  int status, ret;
+  struct process_info *process = find_process_pid (pid);
+  if (process == NULL)
+    return -1;
+
+  ptrace (PTRACE_KILL, pid, 0, 0);
+
+  do {
+    ret = waitpid (pid, &status, 0);
+    if (WIFEXITED (status) || WIFSIGNALED (status))
+      break;
+  } while (ret != -1 || errno != ECHILD);
+
+  clear_inferiors ();
+  remove_process (process);
+  return 0;

 }
 
 /* Detach from inferior process.  */
 }
 
 /* Detach from inferior process.  */

+static int
+spu_detach (int pid)
+{
+  struct process_info *process = find_process_pid (pid);
+  if (process == NULL)
+    return -1;
+
+  ptrace (PTRACE_DETACH, pid, 0, 0);
+
+  clear_inferiors ();
+  remove_process (process);
+  return 0;
+}
+
+static void
+spu_mourn (struct process_info *process)
+{
+  remove_process (process);
+}
+

 static void
 static void

-spu_detach (void)
+spu_join (int pid)

 {
 {

-  ptrace (PTRACE_DETACH, current_tid, 0, 0);
+  int status, ret;
+  struct process_info *process;
+
+  process = find_process_pid (pid);
+  if (process == NULL)
+    return;
+
+  do {
+    ret = waitpid (pid, &status, 0);
+    if (WIFEXITED (status) || WIFSIGNALED (status))
+      break;
+  } while (ret != -1 || errno != ECHILD);

 }
 
 /* Return nonzero if the given thread is still alive.  */
 static int
 }
 
 /* Return nonzero if the given thread is still alive.  */
 static int

-spu_thread_alive (unsigned long tid)
+spu_thread_alive (ptid_t ptid)

 {
 {

-  return tid == current_tid;
+  return ptid_equal (ptid, current_ptid);

 }
 
 /* Resume process.  */
 static void
 }
 
 /* Resume process.  */
 static void

-spu_resume (struct thread_resume *resume_info)
+spu_resume (struct thread_resume *resume_info, size_t n)

 {
 {

-  while (resume_info->thread != -1
-        && resume_info->thread != current_tid)
-    resume_info++;
+  size_t i;

 
 

-  block_async_io ();
-  enable_async_io ();
+  for (i = 0; i < n; i++)
+    if (ptid_equal (resume_info[i].thread, minus_one_ptid)
+       || ptid_equal (resume_info[i].thread, current_ptid))
+      break;

 
 

-  if (resume_info->leave_stopped)
+  if (i == n)

     return;
 
   /* We don't support hardware single-stepping right now, assume
      GDB knows to use software single-stepping.  */
     return;
 
   /* We don't support hardware single-stepping right now, assume
      GDB knows to use software single-stepping.  */

-  if (resume_info->step)
+  if (resume_info[i].kind == resume_step)

     fprintf (stderr, "Hardware single-step not supported.\n");
 
   regcache_invalidate ();
 
   errno = 0;
     fprintf (stderr, "Hardware single-step not supported.\n");
 
   regcache_invalidate ();
 
   errno = 0;

-  ptrace (PTRACE_CONT, current_tid, 0, resume_info->sig);
+  ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig);

   if (errno)
     perror_with_name ("ptrace");
 }
 
 /* Wait for process, returns status.  */
   if (errno)
     perror_with_name ("ptrace");
 }
 
 /* Wait for process, returns status.  */

-static unsigned char
-spu_wait (char *status)
+static ptid_t
+spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)

 {
 {

-  int tid = current_tid;
+  int pid = ptid_get_pid (ptid);

   int w;
   int ret;
 
   int w;
   int ret;
 

-  enable_async_io ();
-  unblock_async_io ();
-

   while (1)
     {
   while (1)
     {

-      ret = waitpid (tid, &w, WNOHANG | __WALL | __WNOTHREAD);
+      ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);

 
       if (ret == -1)
        {
 
       if (ret == -1)
        {


@@ -390,65 +443,63 @@ spu_wait (char *status)
 
       while (!parse_spufs_run (&fd, &addr))
        {
 
       while (!parse_spufs_run (&fd, &addr))
        {

-         ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
-         waitpid (tid, NULL, __WALL | __WNOTHREAD);
+         ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
+         waitpid (pid, NULL, __WALL | __WNOTHREAD);

        }
     }
 
        }
     }
 

-  disable_async_io ();
-

   if (WIFEXITED (w))
     {
       fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
   if (WIFEXITED (w))
     {
       fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));

-      *status = 'W';
+      ourstatus->kind =  TARGET_WAITKIND_EXITED;
+      ourstatus->value.integer = WEXITSTATUS (w);

       clear_inferiors ();
       clear_inferiors ();

-      return ((unsigned char) WEXITSTATUS (w));
+      return pid_to_ptid (ret);

     }
   else if (!WIFSTOPPED (w))
     {
       fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
     }
   else if (!WIFSTOPPED (w))
     {
       fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));

-      *status = 'X';
+      ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+      ourstatus->value.sig = target_signal_from_host (WTERMSIG (w));

       clear_inferiors ();
       clear_inferiors ();

-      return ((unsigned char) WTERMSIG (w));
+      return pid_to_ptid (ret);

     }
 
   /* After attach, we may have received a SIGSTOP.  Do not return this
      as signal to GDB, or else it will try to continue with SIGSTOP ...  */
   if (!server_waiting)
     {
     }
 
   /* After attach, we may have received a SIGSTOP.  Do not return this
      as signal to GDB, or else it will try to continue with SIGSTOP ...  */
   if (!server_waiting)
     {

-      *status = 'T';
-      return 0;
+      ourstatus->kind = TARGET_WAITKIND_STOPPED;
+      ourstatus->value.sig = TARGET_SIGNAL_0;
+      return ptid_build (ret, ret, 0);

     }
 
     }
 

-  *status = 'T';
-  return ((unsigned char) WSTOPSIG (w));
+  ourstatus->kind = TARGET_WAITKIND_STOPPED;
+  ourstatus->value.sig = target_signal_from_host (WSTOPSIG (w));
+  return ptid_build (ret, ret, 0);

 }
 
 /* Fetch inferior registers.  */
 static void
 }
 
 /* Fetch inferior registers.  */
 static void

-spu_fetch_registers (int regno)
+spu_fetch_registers (struct regcache *regcache, int regno)

 {
   int fd;
   CORE_ADDR addr;
 
 {
   int fd;
   CORE_ADDR addr;
 

-  /* ??? Some callers use 0 to mean all registers.  */
-  if (regno == 0)
-    regno = -1;
-

   /* We must be stopped on a spu_run system call.  */
   if (!parse_spufs_run (&fd, &addr))
     return;
 
   /* The ID register holds the spufs file handle.  */
   if (regno == -1 || regno == SPU_ID_REGNUM)
   /* We must be stopped on a spu_run system call.  */
   if (!parse_spufs_run (&fd, &addr))
     return;
 
   /* The ID register holds the spufs file handle.  */
   if (regno == -1 || regno == SPU_ID_REGNUM)

-    supply_register (SPU_ID_REGNUM, (char *)&fd);
+    supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);

 
   /* The NPC register is found at ADDR.  */
   if (regno == -1 || regno == SPU_PC_REGNUM)
     {
       char buf[4];
       if (fetch_ppc_memory (addr, buf, 4) == 0)
 
   /* The NPC register is found at ADDR.  */
   if (regno == -1 || regno == SPU_PC_REGNUM)
     {
       char buf[4];
       if (fetch_ppc_memory (addr, buf, 4) == 0)

-       supply_register (SPU_PC_REGNUM, buf);
+       supply_register (regcache, SPU_PC_REGNUM, buf);

     }
 
   /* The GPRs are found in the "regs" spufs file.  */
     }
 
   /* The GPRs are found in the "regs" spufs file.  */


@@ -461,13 +512,13 @@ spu_fetch_registers (int regno)
       sprintf (annex, "%d/regs", fd);
       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
        for (i = 0; i < SPU_NUM_CORE_REGS; i++)
       sprintf (annex, "%d/regs", fd);
       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
        for (i = 0; i < SPU_NUM_CORE_REGS; i++)

-         supply_register (i, buf + i*16);
+         supply_register (regcache, i, buf + i*16);

     }
 }
 
 /* Store inferior registers.  */
 static void
     }
 }
 
 /* Store inferior registers.  */
 static void

-spu_store_registers (int regno)
+spu_store_registers (struct regcache *regcache, int regno)

 {
   int fd;
   CORE_ADDR addr;
 {
   int fd;
   CORE_ADDR addr;


@@ -484,7 +535,7 @@ spu_store_registers (int regno)
   if (regno == -1 || regno == SPU_PC_REGNUM)
     {
       char buf[4];
   if (regno == -1 || regno == SPU_PC_REGNUM)
     {
       char buf[4];

-      collect_register (SPU_PC_REGNUM, buf);
+      collect_register (regcache, SPU_PC_REGNUM, buf);

       store_ppc_memory (addr, buf, 4);
     }
 
       store_ppc_memory (addr, buf, 4);
     }
 


@@ -496,7 +547,7 @@ spu_store_registers (int regno)
       int i;
 
       for (i = 0; i < SPU_NUM_CORE_REGS; i++)
       int i;
 
       for (i = 0; i < SPU_NUM_CORE_REGS; i++)

-       collect_register (i, buf + i*16);
+       collect_register (regcache, i, buf + i*16);

 
       sprintf (annex, "%d/regs", fd);
       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 
       sprintf (annex, "%d/regs", fd);
       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);


@@ -510,7 +561,8 @@ spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 {
   int fd, ret;
   CORE_ADDR addr;
 {
   int fd, ret;
   CORE_ADDR addr;

-  char annex[32];
+  char annex[32], lslr_annex[32], buf[32];
+  CORE_ADDR lslr;

 
   /* 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))


@@ -519,6 +571,22 @@ spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
   /* Use the "mem" spufs file to access SPU local store.  */
   sprintf (annex, "%d/mem", fd);
   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
   /* Use the "mem" spufs file to access SPU local store.  */
   sprintf (annex, "%d/mem", fd);
   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);

+  if (ret > 0)
+    return ret == len ? 0 : EIO;
+
+  /* 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.  */
+  sprintf (lslr_annex, "%d/lslr", fd);
+  memset (buf, 0, sizeof buf);
+  if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
+                        0, sizeof buf) <= 0)
+    return ret;
+
+  lslr = strtoul (buf, NULL, 16);
+  ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
+

   return ret == len ? 0 : EIO;
 }
 
   return ret == len ? 0 : EIO;
 }
 


@@ -531,7 +599,8 @@ spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
 {
   int fd, ret;
   CORE_ADDR addr;
 {
   int fd, ret;
   CORE_ADDR addr;

-  char annex[32];
+  char annex[32], lslr_annex[32], buf[32];
+  CORE_ADDR lslr;

 
   /* 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))


@@ -540,6 +609,22 @@ spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
   /* Use the "mem" spufs file to access SPU local store.  */
   sprintf (annex, "%d/mem", fd);
   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
   /* Use the "mem" spufs file to access SPU local store.  */
   sprintf (annex, "%d/mem", fd);
   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);

+  if (ret > 0)
+    return ret == len ? 0 : EIO;
+
+  /* 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.  */
+  sprintf (lslr_annex, "%d/lslr", fd);
+  memset (buf, 0, sizeof buf);
+  if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
+                        0, sizeof buf) <= 0)
+    return ret;
+
+  lslr = strtoul (buf, NULL, 16);
+  ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
+

   return ret == len ? 0 : EIO;
 }
 
   return ret == len ? 0 : EIO;
 }
 


@@ -551,27 +636,38 @@ spu_look_up_symbols (void)
 
 /* Send signal to inferior.  */
 static void
 
 /* Send signal to inferior.  */
 static void

-spu_send_signal (int signo)
+spu_request_interrupt (void)

 {
 {

-  syscall (SYS_tkill, current_tid, signo);
+  syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);

 }
 
 }
 

-\f

 static struct target_ops spu_target_ops = {
   spu_create_inferior,
   spu_attach,
   spu_kill,
   spu_detach,
 static struct target_ops spu_target_ops = {
   spu_create_inferior,
   spu_attach,
   spu_kill,
   spu_detach,

+  spu_mourn,
+  spu_join,

   spu_thread_alive,
   spu_resume,
   spu_wait,
   spu_fetch_registers,
   spu_store_registers,
   spu_thread_alive,
   spu_resume,
   spu_wait,
   spu_fetch_registers,
   spu_store_registers,

+  NULL, /* prepare_to_access_memory */
+  NULL, /* unprepare_to_access_memory */

   spu_read_memory,
   spu_write_memory,
   spu_look_up_symbols,
   spu_read_memory,
   spu_write_memory,
   spu_look_up_symbols,

-  spu_send_signal,
+  spu_request_interrupt,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,

   NULL,
   NULL,

+  spu_proc_xfer_spu,
+  hostio_last_error_from_errno,

 };
 
 void
 };
 
 void


@@ -581,5 +677,5 @@ initialize_low (void)
 
   set_target_ops (&spu_target_ops);
   set_breakpoint_data (breakpoint, sizeof breakpoint);
 
   set_target_ops (&spu_target_ops);
   set_breakpoint_data (breakpoint, sizeof breakpoint);

-  init_registers ();
+  init_registers_spu ();

 }
 }