OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [spu-linux-nat.c] - Diff between revs 227 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 227 Rev 816
/* SPU native-dependent code for GDB, the GNU debugger.
/* SPU native-dependent code for GDB, the GNU debugger.
   Copyright (C) 2006, 2007, 2008, 2009, 2010 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>.
 
 
   This file is part of GDB.
   This file is part of GDB.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
#include "defs.h"
#include "defs.h"
#include "gdbcore.h"
#include "gdbcore.h"
#include "gdb_string.h"
#include "gdb_string.h"
#include "target.h"
#include "target.h"
#include "inferior.h"
#include "inferior.h"
#include "inf-ptrace.h"
#include "inf-ptrace.h"
#include "regcache.h"
#include "regcache.h"
#include "symfile.h"
#include "symfile.h"
#include "gdb_wait.h"
#include "gdb_wait.h"
#include "gdbthread.h"
#include "gdbthread.h"
 
 
#include <sys/ptrace.h>
#include <sys/ptrace.h>
#include <asm/ptrace.h>
#include <asm/ptrace.h>
#include <sys/types.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/param.h>
 
 
#include "spu-tdep.h"
#include "spu-tdep.h"
 
 
/* PPU side system calls.  */
/* PPU side system calls.  */
#define INSTR_SC        0x44000002
#define INSTR_SC        0x44000002
#define NR_spu_run      0x0116
#define NR_spu_run      0x0116
 
 
 
 
/* Fetch PPU register REGNO.  */
/* Fetch PPU register REGNO.  */
static ULONGEST
static ULONGEST
fetch_ppc_register (int regno)
fetch_ppc_register (int regno)
{
{
  PTRACE_TYPE_RET res;
  PTRACE_TYPE_RET res;
 
 
  int tid = TIDGET (inferior_ptid);
  int tid = TIDGET (inferior_ptid);
  if (tid == 0)
  if (tid == 0)
    tid = PIDGET (inferior_ptid);
    tid = PIDGET (inferior_ptid);
 
 
#ifndef __powerpc64__
#ifndef __powerpc64__
  /* If running as a 32-bit process on a 64-bit system, we attempt
  /* If running as a 32-bit process on a 64-bit system, we attempt
     to get the full 64-bit register content of the target process.
     to get the full 64-bit register content of the target process.
     If the PPC special ptrace call fails, we're on a 32-bit system;
     If the PPC special ptrace call fails, we're on a 32-bit system;
     just fall through to the regular ptrace call in that case.  */
     just fall through to the regular ptrace call in that case.  */
  {
  {
    gdb_byte buf[8];
    gdb_byte buf[8];
 
 
    errno = 0;
    errno = 0;
    ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
    ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
            (PTRACE_TYPE_ARG3) (regno * 8), buf);
            (PTRACE_TYPE_ARG3) (regno * 8), buf);
    if (errno == 0)
    if (errno == 0)
      ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
      ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
              (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
              (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
    if (errno == 0)
    if (errno == 0)
      return (ULONGEST) *(uint64_t *)buf;
      return (ULONGEST) *(uint64_t *)buf;
  }
  }
#endif
#endif
 
 
  errno = 0;
  errno = 0;
  res = ptrace (PT_READ_U, tid,
  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)
  if (errno != 0)
    {
    {
      char mess[128];
      char mess[128];
      xsnprintf (mess, sizeof mess, "reading PPC register #%d", regno);
      xsnprintf (mess, sizeof mess, "reading PPC register #%d", regno);
      perror_with_name (_(mess));
      perror_with_name (_(mess));
    }
    }
 
 
  return (ULONGEST) (unsigned long) res;
  return (ULONGEST) (unsigned long) res;
}
}
 
 
/* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
/* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
static int
static int
fetch_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
fetch_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
{
{
  errno = 0;
  errno = 0;
 
 
#ifndef __powerpc64__
#ifndef __powerpc64__
  if (memaddr >> 32)
  if (memaddr >> 32)
    {
    {
      uint64_t addr_8 = (uint64_t) memaddr;
      uint64_t addr_8 = (uint64_t) memaddr;
      ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
      ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
    }
    }
  else
  else
#endif
#endif
    *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
    *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
 
 
  return errno;
  return errno;
}
}
 
 
/* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
/* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
static int
static int
store_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
store_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
{
{
  errno = 0;
  errno = 0;
 
 
#ifndef __powerpc64__
#ifndef __powerpc64__
  if (memaddr >> 32)
  if (memaddr >> 32)
    {
    {
      uint64_t addr_8 = (uint64_t) memaddr;
      uint64_t addr_8 = (uint64_t) memaddr;
      ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
      ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
    }
    }
  else
  else
#endif
#endif
    ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
    ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
 
 
  return errno;
  return errno;
}
}
 
 
/* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
/* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
static int
static int
fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
{
{
  int i, ret;
  int i, ret;
 
 
  ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
  ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
               / sizeof (PTRACE_TYPE_RET));
               / sizeof (PTRACE_TYPE_RET));
  PTRACE_TYPE_RET *buffer;
  PTRACE_TYPE_RET *buffer;
 
 
  int tid = TIDGET (inferior_ptid);
  int tid = TIDGET (inferior_ptid);
  if (tid == 0)
  if (tid == 0)
    tid = PIDGET (inferior_ptid);
    tid = PIDGET (inferior_ptid);
 
 
  buffer = (PTRACE_TYPE_RET *) alloca (count * 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))
  for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
    {
    {
      ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
      ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
      if (ret)
      if (ret)
        return ret;
        return ret;
    }
    }
 
 
  memcpy (myaddr,
  memcpy (myaddr,
          (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
          (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
          len);
          len);
 
 
  return 0;
  return 0;
}
}
 
 
/* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
/* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
static int
static int
store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
{
{
  int i, ret;
  int i, ret;
 
 
  ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
  ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
               / sizeof (PTRACE_TYPE_RET));
               / sizeof (PTRACE_TYPE_RET));
  PTRACE_TYPE_RET *buffer;
  PTRACE_TYPE_RET *buffer;
 
 
  int tid = TIDGET (inferior_ptid);
  int tid = TIDGET (inferior_ptid);
  if (tid == 0)
  if (tid == 0)
    tid = PIDGET (inferior_ptid);
    tid = PIDGET (inferior_ptid);
 
 
  buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
  buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 
 
  if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
  if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
    {
    {
      ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
      ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
      if (ret)
      if (ret)
        return ret;
        return ret;
    }
    }
 
 
  if (count > 1)
  if (count > 1)
    {
    {
      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]);
                                &buffer[count - 1]);
      if (ret)
      if (ret)
        return ret;
        return ret;
    }
    }
 
 
  memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
  memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
          myaddr, len);
          myaddr, len);
 
 
  for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
  for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
    {
    {
      ret = store_ppc_memory_1 (tid, addr, buffer[i]);
      ret = store_ppc_memory_1 (tid, addr, buffer[i]);
      if (ret)
      if (ret)
        return ret;
        return ret;
    }
    }
 
 
  return 0;
  return 0;
}
}
 
 
 
 
/* If the PPU thread is currently stopped on a spu_run system call,
/* 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
   return to FD and ADDR the file handle and NPC parameter address
   used with the system call.  Return non-zero if successful.  */
   used with the system call.  Return non-zero if successful.  */
static int
static int
parse_spufs_run (int *fd, ULONGEST *addr)
parse_spufs_run (int *fd, ULONGEST *addr)
{
{
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
  gdb_byte buf[4];
  gdb_byte buf[4];
  ULONGEST pc = fetch_ppc_register (32);  /* nip */
  ULONGEST pc = fetch_ppc_register (32);  /* nip */
 
 
  /* Fetch instruction preceding current NIP.  */
  /* Fetch instruction preceding current NIP.  */
  if (fetch_ppc_memory (pc-4, buf, 4) != 0)
  if (fetch_ppc_memory (pc-4, buf, 4) != 0)
    return 0;
    return 0;
  /* It should be a "sc" instruction.  */
  /* It should be a "sc" instruction.  */
  if (extract_unsigned_integer (buf, 4, byte_order) != INSTR_SC)
  if (extract_unsigned_integer (buf, 4, byte_order) != INSTR_SC)
    return 0;
    return 0;
  /* System call number should be NR_spu_run.  */
  /* System call number should be NR_spu_run.  */
  if (fetch_ppc_register (0) != NR_spu_run)
  if (fetch_ppc_register (0) != NR_spu_run)
    return 0;
    return 0;
 
 
  /* Register 3 contains fd, register 4 the NPC param pointer.  */
  /* Register 3 contains fd, register 4 the NPC param pointer.  */
  *fd = fetch_ppc_register (34);  /* orig_gpr3 */
  *fd = fetch_ppc_register (34);  /* orig_gpr3 */
  *addr = fetch_ppc_register (4);
  *addr = fetch_ppc_register (4);
  return 1;
  return 1;
}
}
 
 
 
 
/* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
/* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
   using the /proc file system.  */
   using the /proc file system.  */
static LONGEST
static LONGEST
spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
                   const gdb_byte *writebuf,
                   const gdb_byte *writebuf,
                   ULONGEST offset, LONGEST len)
                   ULONGEST offset, LONGEST len)
{
{
  char buf[128];
  char buf[128];
  int fd = 0;
  int fd = 0;
  int ret = -1;
  int ret = -1;
  int pid = PIDGET (inferior_ptid);
  int pid = PIDGET (inferior_ptid);
 
 
  if (!annex)
  if (!annex)
    return 0;
    return 0;
 
 
  xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
  xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
  fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
  fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
  if (fd <= 0)
  if (fd <= 0)
    return -1;
    return -1;
 
 
  if (offset != 0
  if (offset != 0
      && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
      && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
    {
    {
      close (fd);
      close (fd);
      return 0;
      return 0;
    }
    }
 
 
  if (writebuf)
  if (writebuf)
    ret = write (fd, writebuf, (size_t) len);
    ret = write (fd, writebuf, (size_t) len);
  else if (readbuf)
  else if (readbuf)
    ret = read (fd, readbuf, (size_t) len);
    ret = read (fd, readbuf, (size_t) len);
 
 
  close (fd);
  close (fd);
  return ret;
  return ret;
}
}
 
 
 
 
/* Inferior memory should contain an SPE executable image at location ADDR.
/* Inferior memory should contain an SPE executable image at location ADDR.
   Allocate a BFD representing that executable.  Return NULL on error.  */
   Allocate a BFD representing that executable.  Return NULL on error.  */
 
 
static void *
static void *
spu_bfd_iovec_open (struct bfd *nbfd, void *open_closure)
spu_bfd_iovec_open (struct bfd *nbfd, void *open_closure)
{
{
  return open_closure;
  return open_closure;
}
}
 
 
static int
static int
spu_bfd_iovec_close (struct bfd *nbfd, void *stream)
spu_bfd_iovec_close (struct bfd *nbfd, void *stream)
{
{
  xfree (stream);
  xfree (stream);
  return 1;
  return 1;
}
}
 
 
static file_ptr
static file_ptr
spu_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
spu_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
                     file_ptr nbytes, file_ptr offset)
                     file_ptr nbytes, file_ptr offset)
{
{
  ULONGEST addr = *(ULONGEST *)stream;
  ULONGEST addr = *(ULONGEST *)stream;
 
 
  if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
  if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
    {
    {
      bfd_set_error (bfd_error_invalid_operation);
      bfd_set_error (bfd_error_invalid_operation);
      return -1;
      return -1;
    }
    }
 
 
  return nbytes;
  return nbytes;
}
}
 
 
static int
static int
spu_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
spu_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
{
{
  /* We don't have an easy way of finding the size of embedded spu
  /* We don't have an easy way of finding the size of embedded spu
     images.  We could parse the in-memory ELF header and section
     images.  We could parse the in-memory ELF header and section
     table to find the extent of the last section but that seems
     table to find the extent of the last section but that seems
     pointless when the size is needed only for checks of other
     pointless when the size is needed only for checks of other
     parsed values in dbxread.c.  */
     parsed values in dbxread.c.  */
  sb->st_size = INT_MAX;
  sb->st_size = INT_MAX;
  return 0;
  return 0;
}
}
 
 
static bfd *
static bfd *
spu_bfd_open (ULONGEST addr)
spu_bfd_open (ULONGEST addr)
{
{
  struct bfd *nbfd;
  struct bfd *nbfd;
  asection *spu_name;
  asection *spu_name;
 
 
  ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
  ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
  *open_closure = addr;
  *open_closure = addr;
 
 
  nbfd = bfd_openr_iovec (xstrdup ("<in-memory>"), "elf32-spu",
  nbfd = bfd_openr_iovec (xstrdup ("<in-memory>"), "elf32-spu",
                          spu_bfd_iovec_open, open_closure,
                          spu_bfd_iovec_open, open_closure,
                          spu_bfd_iovec_pread, spu_bfd_iovec_close,
                          spu_bfd_iovec_pread, spu_bfd_iovec_close,
                          spu_bfd_iovec_stat);
                          spu_bfd_iovec_stat);
  if (!nbfd)
  if (!nbfd)
    return NULL;
    return NULL;
 
 
  if (!bfd_check_format (nbfd, bfd_object))
  if (!bfd_check_format (nbfd, bfd_object))
    {
    {
      bfd_close (nbfd);
      bfd_close (nbfd);
      return NULL;
      return NULL;
    }
    }
 
 
  /* Retrieve SPU name note and update BFD name.  */
  /* Retrieve SPU name note and update BFD name.  */
  spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
  spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
  if (spu_name)
  if (spu_name)
    {
    {
      int sect_size = bfd_section_size (nbfd, spu_name);
      int sect_size = bfd_section_size (nbfd, spu_name);
      if (sect_size > 20)
      if (sect_size > 20)
        {
        {
          char *buf = alloca (sect_size - 20 + 1);
          char *buf = alloca (sect_size - 20 + 1);
          bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
          bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
          buf[sect_size - 20] = '\0';
          buf[sect_size - 20] = '\0';
 
 
          xfree ((char *)nbfd->filename);
          xfree ((char *)nbfd->filename);
          nbfd->filename = xstrdup (buf);
          nbfd->filename = xstrdup (buf);
        }
        }
    }
    }
 
 
  return nbfd;
  return nbfd;
}
}
 
 
/* INFERIOR_FD is a file handle passed by the inferior to the
/* INFERIOR_FD is a file handle passed by the inferior to the
   spu_run system call.  Assuming the SPE context was allocated
   spu_run system call.  Assuming the SPE context was allocated
   by the libspe library, try to retrieve the main SPE executable
   by the libspe library, try to retrieve the main SPE executable
   file from its copy within the target process.  */
   file from its copy within the target process.  */
static void
static void
spu_symbol_file_add_from_memory (int inferior_fd)
spu_symbol_file_add_from_memory (int inferior_fd)
{
{
  ULONGEST addr;
  ULONGEST addr;
  struct bfd *nbfd;
  struct bfd *nbfd;
 
 
  char id[128];
  char id[128];
  char annex[32];
  char annex[32];
  int len;
  int len;
 
 
  /* Read object ID.  */
  /* Read object ID.  */
  xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
  xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
  len = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id);
  len = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id);
  if (len <= 0 || len >= sizeof id)
  if (len <= 0 || len >= sizeof id)
    return;
    return;
  id[len] = 0;
  id[len] = 0;
  addr = strtoulst (id, NULL, 16);
  addr = strtoulst (id, NULL, 16);
  if (!addr)
  if (!addr)
    return;
    return;
 
 
  /* Open BFD representing SPE executable and read its symbols.  */
  /* Open BFD representing SPE executable and read its symbols.  */
  nbfd = spu_bfd_open (addr);
  nbfd = spu_bfd_open (addr);
  if (nbfd)
  if (nbfd)
    symbol_file_add_from_bfd (nbfd, SYMFILE_VERBOSE | SYMFILE_MAINLINE,
    symbol_file_add_from_bfd (nbfd, SYMFILE_VERBOSE | SYMFILE_MAINLINE,
                              NULL, 0);
                              NULL, 0);
}
}
 
 
 
 
/* Override the post_startup_inferior routine to continue running
/* Override the post_startup_inferior routine to continue running
   the inferior until the first spu_run system call.  */
   the inferior until the first spu_run system call.  */
static void
static void
spu_child_post_startup_inferior (ptid_t ptid)
spu_child_post_startup_inferior (ptid_t ptid)
{
{
  int fd;
  int fd;
  ULONGEST addr;
  ULONGEST addr;
 
 
  int tid = TIDGET (ptid);
  int tid = TIDGET (ptid);
  if (tid == 0)
  if (tid == 0)
    tid = PIDGET (ptid);
    tid = PIDGET (ptid);
 
 
  while (!parse_spufs_run (&fd, &addr))
  while (!parse_spufs_run (&fd, &addr))
    {
    {
      ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
      ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
      waitpid (tid, NULL, __WALL | __WNOTHREAD);
      waitpid (tid, NULL, __WALL | __WNOTHREAD);
    }
    }
}
}
 
 
/* Override the post_attach routine to try load the SPE executable
/* Override the post_attach routine to try load the SPE executable
   file image from its copy inside the target process.  */
   file image from its copy inside the target process.  */
static void
static void
spu_child_post_attach (int pid)
spu_child_post_attach (int pid)
{
{
  int fd;
  int fd;
  ULONGEST addr;
  ULONGEST addr;
 
 
  /* Like child_post_startup_inferior, if we happened to attach to
  /* Like child_post_startup_inferior, if we happened to attach to
     the inferior while it wasn't currently in spu_run, continue
     the inferior while it wasn't currently in spu_run, continue
     running it until we get back there.  */
     running it until we get back there.  */
  while (!parse_spufs_run (&fd, &addr))
  while (!parse_spufs_run (&fd, &addr))
    {
    {
      ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
      ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
      waitpid (pid, NULL, __WALL | __WNOTHREAD);
      waitpid (pid, NULL, __WALL | __WNOTHREAD);
    }
    }
 
 
  /* If the user has not provided an executable file, try to extract
  /* If the user has not provided an executable file, try to extract
     the image from inside the target process.  */
     the image from inside the target process.  */
  if (!get_exec_file (0))
  if (!get_exec_file (0))
    spu_symbol_file_add_from_memory (fd);
    spu_symbol_file_add_from_memory (fd);
}
}
 
 
/* Wait for child PTID to do something.  Return id of the child,
/* Wait for child PTID to do something.  Return id of the child,
   minus_one_ptid in case of error; store status into *OURSTATUS.  */
   minus_one_ptid in case of error; store status into *OURSTATUS.  */
static ptid_t
static ptid_t
spu_child_wait (struct target_ops *ops,
spu_child_wait (struct target_ops *ops,
                ptid_t ptid, struct target_waitstatus *ourstatus, int options)
                ptid_t ptid, struct target_waitstatus *ourstatus, int options)
{
{
  int save_errno;
  int save_errno;
  int status;
  int status;
  pid_t pid;
  pid_t pid;
 
 
  do
  do
    {
    {
      set_sigint_trap ();       /* Causes SIGINT to be passed on to the
      set_sigint_trap ();       /* Causes SIGINT to be passed on to the
                                   attached process.  */
                                   attached process.  */
 
 
      pid = waitpid (PIDGET (ptid), &status, 0);
      pid = waitpid (PIDGET (ptid), &status, 0);
      if (pid == -1 && errno == ECHILD)
      if (pid == -1 && errno == ECHILD)
        /* Try again with __WCLONE to check cloned processes.  */
        /* Try again with __WCLONE to check cloned processes.  */
        pid = waitpid (PIDGET (ptid), &status, __WCLONE);
        pid = waitpid (PIDGET (ptid), &status, __WCLONE);
 
 
      save_errno = errno;
      save_errno = errno;
 
 
      /* Make sure we don't report an event for the exit of the
      /* Make sure we don't report an event for the exit of the
         original program, if we've detached from it.  */
         original program, if we've detached from it.  */
      if (pid != -1 && !WIFSTOPPED (status) && pid != PIDGET (inferior_ptid))
      if (pid != -1 && !WIFSTOPPED (status) && pid != PIDGET (inferior_ptid))
        {
        {
          pid = -1;
          pid = -1;
          save_errno = EINTR;
          save_errno = EINTR;
        }
        }
 
 
      clear_sigint_trap ();
      clear_sigint_trap ();
    }
    }
  while (pid == -1 && save_errno == EINTR);
  while (pid == -1 && save_errno == EINTR);
 
 
  if (pid == -1)
  if (pid == -1)
    {
    {
      warning (_("Child process unexpectedly missing: %s"),
      warning (_("Child process unexpectedly missing: %s"),
               safe_strerror (save_errno));
               safe_strerror (save_errno));
 
 
      /* Claim it exited with unknown signal.  */
      /* Claim it exited with unknown signal.  */
      ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
      ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
      ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
      ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
      return inferior_ptid;
      return inferior_ptid;
    }
    }
 
 
  store_waitstatus (ourstatus, status);
  store_waitstatus (ourstatus, status);
  return pid_to_ptid (pid);
  return pid_to_ptid (pid);
}
}
 
 
/* Override the fetch_inferior_register routine.  */
/* Override the fetch_inferior_register routine.  */
static void
static void
spu_fetch_inferior_registers (struct target_ops *ops,
spu_fetch_inferior_registers (struct target_ops *ops,
                              struct regcache *regcache, int regno)
                              struct regcache *regcache, int regno)
{
{
  int fd;
  int fd;
  ULONGEST addr;
  ULONGEST addr;
 
 
  /* We must be stopped on a spu_run system call.  */
  /* We must be stopped on a spu_run system call.  */
  if (!parse_spufs_run (&fd, &addr))
  if (!parse_spufs_run (&fd, &addr))
    return;
    return;
 
 
  /* The ID register holds the spufs file handle.  */
  /* The ID register holds the spufs file handle.  */
  if (regno == -1 || regno == SPU_ID_REGNUM)
  if (regno == -1 || regno == SPU_ID_REGNUM)
    {
    {
      struct gdbarch *gdbarch = get_regcache_arch (regcache);
      struct gdbarch *gdbarch = get_regcache_arch (regcache);
      enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
      enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
      char buf[4];
      char buf[4];
      store_unsigned_integer (buf, 4, byte_order, 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);
    }
    }
 
 
  /* The NPC register is found at ADDR.  */
  /* The NPC register is found at ADDR.  */
  if (regno == -1 || regno == SPU_PC_REGNUM)
  if (regno == -1 || regno == SPU_PC_REGNUM)
    {
    {
      gdb_byte buf[4];
      gdb_byte buf[4];
      if (fetch_ppc_memory (addr, buf, 4) == 0)
      if (fetch_ppc_memory (addr, buf, 4) == 0)
        regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
        regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
    }
    }
 
 
  /* The GPRs are found in the "regs" spufs file.  */
  /* The GPRs are found in the "regs" spufs file.  */
  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
    {
    {
      gdb_byte buf[16 * SPU_NUM_GPRS];
      gdb_byte buf[16 * SPU_NUM_GPRS];
      char annex[32];
      char annex[32];
      int i;
      int i;
 
 
      xsnprintf (annex, sizeof annex, "%d/regs", fd);
      xsnprintf (annex, sizeof annex, "%d/regs", fd);
      if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
      if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
        for (i = 0; i < SPU_NUM_GPRS; i++)
        for (i = 0; i < SPU_NUM_GPRS; i++)
          regcache_raw_supply (regcache, i, buf + i*16);
          regcache_raw_supply (regcache, i, buf + i*16);
    }
    }
}
}
 
 
/* Override the store_inferior_register routine.  */
/* Override the store_inferior_register routine.  */
static void
static void
spu_store_inferior_registers (struct target_ops *ops,
spu_store_inferior_registers (struct target_ops *ops,
                              struct regcache *regcache, int regno)
                              struct regcache *regcache, int regno)
{
{
  int fd;
  int fd;
  ULONGEST addr;
  ULONGEST addr;
 
 
  /* We must be stopped on a spu_run system call.  */
  /* We must be stopped on a spu_run system call.  */
  if (!parse_spufs_run (&fd, &addr))
  if (!parse_spufs_run (&fd, &addr))
    return;
    return;
 
 
  /* The NPC register is found at ADDR.  */
  /* The NPC register is found at ADDR.  */
  if (regno == -1 || regno == SPU_PC_REGNUM)
  if (regno == -1 || regno == SPU_PC_REGNUM)
    {
    {
      gdb_byte buf[4];
      gdb_byte buf[4];
      regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
      regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
      store_ppc_memory (addr, buf, 4);
      store_ppc_memory (addr, buf, 4);
    }
    }
 
 
  /* The GPRs are found in the "regs" spufs file.  */
  /* The GPRs are found in the "regs" spufs file.  */
  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
    {
    {
      gdb_byte buf[16 * SPU_NUM_GPRS];
      gdb_byte buf[16 * SPU_NUM_GPRS];
      char annex[32];
      char annex[32];
      int i;
      int i;
 
 
      for (i = 0; i < SPU_NUM_GPRS; i++)
      for (i = 0; i < SPU_NUM_GPRS; i++)
        regcache_raw_collect (regcache, i, buf + i*16);
        regcache_raw_collect (regcache, i, buf + i*16);
 
 
      xsnprintf (annex, sizeof annex, "%d/regs", fd);
      xsnprintf (annex, sizeof annex, "%d/regs", fd);
      spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
      spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
    }
    }
}
}
 
 
/* Override the to_xfer_partial routine.  */
/* Override the to_xfer_partial routine.  */
static LONGEST
static LONGEST
spu_xfer_partial (struct target_ops *ops,
spu_xfer_partial (struct target_ops *ops,
                  enum target_object object, const char *annex,
                  enum target_object object, const char *annex,
                  gdb_byte *readbuf, const gdb_byte *writebuf,
                  gdb_byte *readbuf, const gdb_byte *writebuf,
                  ULONGEST offset, LONGEST len)
                  ULONGEST offset, LONGEST len)
{
{
  if (object == TARGET_OBJECT_SPU)
  if (object == TARGET_OBJECT_SPU)
    return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len);
    return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len);
 
 
  if (object == TARGET_OBJECT_MEMORY)
  if (object == TARGET_OBJECT_MEMORY)
    {
    {
      int fd;
      int fd;
      ULONGEST addr;
      ULONGEST addr;
      char mem_annex[32];
      char mem_annex[32];
 
 
      /* We must be stopped on a spu_run system call.  */
      /* We must be stopped on a spu_run system call.  */
      if (!parse_spufs_run (&fd, &addr))
      if (!parse_spufs_run (&fd, &addr))
        return 0;
        return 0;
 
 
      /* Use the "mem" spufs file to access SPU local store.  */
      /* Use the "mem" spufs file to access SPU local store.  */
      xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
      xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
      return spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
      return spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
    }
    }
 
 
  return -1;
  return -1;
}
}
 
 
/* Override the to_can_use_hw_breakpoint routine.  */
/* Override the to_can_use_hw_breakpoint routine.  */
static int
static int
spu_can_use_hw_breakpoint (int type, int cnt, int othertype)
spu_can_use_hw_breakpoint (int type, int cnt, int othertype)
{
{
  return 0;
  return 0;
}
}
 
 
 
 
/* Initialize SPU native target.  */
/* Initialize SPU native target.  */
void
void
_initialize_spu_nat (void)
_initialize_spu_nat (void)
{
{
  /* Generic ptrace methods.  */
  /* Generic ptrace methods.  */
  struct target_ops *t;
  struct target_ops *t;
  t = inf_ptrace_target ();
  t = inf_ptrace_target ();
 
 
  /* Add SPU methods.  */
  /* Add SPU methods.  */
  t->to_post_attach = spu_child_post_attach;
  t->to_post_attach = spu_child_post_attach;
  t->to_post_startup_inferior = spu_child_post_startup_inferior;
  t->to_post_startup_inferior = spu_child_post_startup_inferior;
  t->to_wait = spu_child_wait;
  t->to_wait = spu_child_wait;
  t->to_fetch_registers = spu_fetch_inferior_registers;
  t->to_fetch_registers = spu_fetch_inferior_registers;
  t->to_store_registers = spu_store_inferior_registers;
  t->to_store_registers = spu_store_inferior_registers;
  t->to_xfer_partial = spu_xfer_partial;
  t->to_xfer_partial = spu_xfer_partial;
  t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
  t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
 
 
  /* Register SPU target.  */
  /* Register SPU target.  */
  add_target (t);
  add_target (t);
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.