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

/* SPU native-dependent code for GDB, the GNU debugger.
   Copyright (C) 2006-2014 Free Software Foundation, Inc.

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

   This file is part of GDB.

   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 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "gdbcore.h"
#include <string.h>
#include "target.h"
#include "inferior.h"
#include "inf-child.h"
#include "inf-ptrace.h"
#include "regcache.h"
#include "symfile.h"
#include "gdb_wait.h"
#include "gdbthread.h"
#include "gdb_bfd.h"

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

#include "spu-tdep.h"

/* PPU side system calls.  */
#define INSTR_SC	0x44000002
#define NR_spu_run	0x0116


/* Fetch PPU register REGNO.  */
static ULONGEST
fetch_ppc_register (int regno)
{
  PTRACE_TYPE_RET res;

  int tid = ptid_get_lwp (inferior_ptid);
  if (tid == 0)
    tid = ptid_get_pid (inferior_ptid);

#ifndef __powerpc64__
  /* 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.
     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.  */
  {
    gdb_byte buf[8];

    errno = 0;
    ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
	    (PTRACE_TYPE_ARG3) (regno * 8), buf);
    if (errno == 0)
      ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
	      (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
    if (errno == 0)
      return (ULONGEST) *(uint64_t *)buf;
  }
#endif

  errno = 0;
  res = ptrace (PT_READ_U, tid,
	 	(PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  if (errno != 0)
    {
      char mess[128];
      xsnprintf (mess, sizeof mess, "reading PPC register #%d", regno);
      perror_with_name (_(mess));
    }

  return (ULONGEST) (unsigned long) res;
}

/* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
static int
fetch_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
{
  errno = 0;

#ifndef __powerpc64__
  if (memaddr >> 32)
    {
      uint64_t addr_8 = (uint64_t) memaddr;
      ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
    }
  else
#endif
    *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);

  return errno;
}

/* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
static int
store_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
{
  errno = 0;

#ifndef __powerpc64__
  if (memaddr >> 32)
    {
      uint64_t addr_8 = (uint64_t) memaddr;
      ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
    }
  else
#endif
    ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);

  return errno;
}

/* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
static int
fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
{
  int i, ret;

  ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
	       / sizeof (PTRACE_TYPE_RET));
  PTRACE_TYPE_RET *buffer;

  int tid = ptid_get_lwp (inferior_ptid);
  if (tid == 0)
    tid = ptid_get_pid (inferior_ptid);

  buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
  for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
    {
      ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
      if (ret)
	return ret;
    }

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

  return 0;
}

/* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
static int
store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
{
  int i, ret;

  ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
	       / sizeof (PTRACE_TYPE_RET));
  PTRACE_TYPE_RET *buffer;

  int tid = ptid_get_lwp (inferior_ptid);
  if (tid == 0)
    tid = ptid_get_pid (inferior_ptid);

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

  if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
    {
      ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
      if (ret)
	return ret;
    }

  if (count > 1)
    {
      ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
					       * sizeof (PTRACE_TYPE_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))
    {
      ret = store_ppc_memory_1 (tid, addr, buffer[i]);
      if (ret)
	return ret;
    }

  return 0;
}


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

  /* Fetch instruction preceding current NIP.  */
  if (fetch_ppc_memory (pc-4, buf, 4) != 0)
    return 0;
  /* It should be a "sc" instruction.  */
  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;

  /* Register 3 contains fd, register 4 the NPC param pointer.  */
  *fd = fetch_ppc_register (34);  /* orig_gpr3 */
  *addr = fetch_ppc_register (4);
  return 1;
}


/* Implement the to_xfer_partial target_ops method for TARGET_OBJECT_SPU.
   Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
   using the /proc file system.  */

static enum target_xfer_status
spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
		   const gdb_byte *writebuf,
		   ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
  char buf[128];
  int fd = 0;
  int ret = -1;
  int pid = ptid_get_pid (inferior_ptid);

  if (!annex)
    return TARGET_XFER_EOF;

  xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
  fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
  if (fd <= 0)
    return TARGET_XFER_E_IO;

  if (offset != 0
      && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
    {
      close (fd);
      return TARGET_XFER_EOF;
    }

  if (writebuf)
    ret = write (fd, writebuf, (size_t) len);
  else if (readbuf)
    ret = read (fd, readbuf, (size_t) len);

  close (fd);
  if (ret < 0)
    return TARGET_XFER_E_IO;
  else if (ret == 0)
    return TARGET_XFER_EOF;
  else
    {
      *xfered_len = (ULONGEST) ret;
      return TARGET_XFER_OK;
    }
}


/* Inferior memory should contain an SPE executable image at location ADDR.
   Allocate a BFD representing that executable.  Return NULL on error.  */

static void *
spu_bfd_iovec_open (struct bfd *nbfd, void *open_closure)
{
  return open_closure;
}

static int
spu_bfd_iovec_close (struct bfd *nbfd, void *stream)
{
  xfree (stream);

  /* Zero means success.  */
  return 0;
}

static file_ptr
spu_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
	             file_ptr nbytes, file_ptr offset)
{
  ULONGEST addr = *(ULONGEST *)stream;

  if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
    {
      bfd_set_error (bfd_error_invalid_operation);
      return -1;
    }

  return nbytes;
}

static int
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
     images.  We could parse the in-memory ELF header and section
     table to find the extent of the last section but that seems
     pointless when the size is needed only for checks of other
     parsed values in dbxread.c.  */
  sb->st_size = INT_MAX;
  return 0;
}

static bfd *
spu_bfd_open (ULONGEST addr)
{
  struct bfd *nbfd;
  asection *spu_name;

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

  nbfd = gdb_bfd_openr_iovec ("<in-memory>", "elf32-spu",
			      spu_bfd_iovec_open, open_closure,
			      spu_bfd_iovec_pread, spu_bfd_iovec_close,
			      spu_bfd_iovec_stat);
  if (!nbfd)
    return NULL;

  if (!bfd_check_format (nbfd, bfd_object))
    {
      gdb_bfd_unref (nbfd);
      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;
}

/* INFERIOR_FD is a file handle passed by the inferior to the
   spu_run system call.  Assuming the SPE context was allocated
   by the libspe library, try to retrieve the main SPE executable
   file from its copy within the target process.  */
static void
spu_symbol_file_add_from_memory (int inferior_fd)
{
  ULONGEST addr;
  struct bfd *nbfd;

  gdb_byte id[128];
  char annex[32];
  ULONGEST len;
  enum target_xfer_status status;

  /* Read object ID.  */
  xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
  status = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id, &len);
  if (status != TARGET_XFER_OK || len >= sizeof id)
    return;
  id[len] = 0;
  addr = strtoulst ((const char *) id, NULL, 16);
  if (!addr)
    return;

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

      symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd),
				SYMFILE_VERBOSE | SYMFILE_MAINLINE,
				NULL, 0, NULL);
      do_cleanups (cleanup);
    }
}


/* Override the post_startup_inferior routine to continue running
   the inferior until the first spu_run system call.  */
static void
spu_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
{
  int fd;
  ULONGEST addr;

  int tid = ptid_get_lwp (ptid);
  if (tid == 0)
    tid = ptid_get_pid (ptid);
  
  while (!parse_spufs_run (&fd, &addr))
    {
      ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
      waitpid (tid, NULL, __WALL | __WNOTHREAD);
    }
}

/* Override the post_attach routine to try load the SPE executable
   file image from its copy inside the target process.  */
static void
spu_child_post_attach (struct target_ops *self, int pid)
{
  int fd;
  ULONGEST addr;

  /* Like child_post_startup_inferior, if we happened to attach to
     the inferior while it wasn't currently in spu_run, continue 
     running it until we get back there.  */
  while (!parse_spufs_run (&fd, &addr))
    {
      ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
      waitpid (pid, NULL, __WALL | __WNOTHREAD);
    }

  /* If the user has not provided an executable file, try to extract
     the image from inside the target process.  */
  if (!get_exec_file (0))
    spu_symbol_file_add_from_memory (fd);
}

/* 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 (struct target_ops *ops,
		ptid_t ptid, struct target_waitstatus *ourstatus, int options)
{
  int save_errno;
  int status;
  pid_t pid;

  do
    {
      set_sigint_trap ();	/* Causes SIGINT to be passed on to the
				   attached process.  */

      pid = waitpid (ptid_get_pid (ptid), &status, 0);
      if (pid == -1 && errno == ECHILD)
	/* Try again with __WCLONE to check cloned processes.  */
	pid = waitpid (ptid_get_pid (ptid), &status, __WCLONE);

      save_errno = errno;

      /* Make sure we don't report an event for the exit of the
         original program, if we've detached from it.  */
      if (pid != -1 && !WIFSTOPPED (status)
	  && pid != ptid_get_pid (inferior_ptid))
	{
	  pid = -1;
	  save_errno = EINTR;
	}

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

  if (pid == -1)
    {
      warning (_("Child process unexpectedly missing: %s"),
	       safe_strerror (save_errno));

      /* Claim it exited with unknown signal.  */
      ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
      ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
      return inferior_ptid;
    }

  store_waitstatus (ourstatus, status);
  return pid_to_ptid (pid);
}

/* Override the fetch_inferior_register routine.  */
static void
spu_fetch_inferior_registers (struct target_ops *ops,
			      struct regcache *regcache, int regno)
{
  int fd;
  ULONGEST addr;

  /* 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)
    {
      struct gdbarch *gdbarch = get_regcache_arch (regcache);
      enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
      gdb_byte buf[4];
      store_unsigned_integer (buf, 4, byte_order, fd);
      regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
    }

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

  /* The GPRs are found in the "regs" spufs file.  */
  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
    {
      gdb_byte buf[16 * SPU_NUM_GPRS];
      char annex[32];
      int i;
      ULONGEST len;

      xsnprintf (annex, sizeof annex, "%d/regs", fd);
      if ((spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf, &len)
	   == TARGET_XFER_OK)
	  && len == sizeof buf)
	for (i = 0; i < SPU_NUM_GPRS; i++)
	  regcache_raw_supply (regcache, i, buf + i*16);
    }
}

/* Override the store_inferior_register routine.  */
static void
spu_store_inferior_registers (struct target_ops *ops,
			      struct regcache *regcache, int regno)
{
  int fd;
  ULONGEST addr;

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

  /* The NPC register is found at ADDR.  */
  if (regno == -1 || regno == SPU_PC_REGNUM)
    {
      gdb_byte buf[4];
      regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
      store_ppc_memory (addr, buf, 4);
    }

  /* The GPRs are found in the "regs" spufs file.  */
  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
    {
      gdb_byte buf[16 * SPU_NUM_GPRS];
      char annex[32];
      int i;
      ULONGEST len;

      for (i = 0; i < SPU_NUM_GPRS; i++)
	regcache_raw_collect (regcache, i, buf + i*16);

      xsnprintf (annex, sizeof annex, "%d/regs", fd);
      spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf, &len);
    }
}

/* Override the to_xfer_partial routine.  */
static enum target_xfer_status
spu_xfer_partial (struct target_ops *ops,
		  enum target_object object, const char *annex,
		  gdb_byte *readbuf, const gdb_byte *writebuf,
		  ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
  if (object == TARGET_OBJECT_SPU)
    return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len,
			      xfered_len);

  if (object == TARGET_OBJECT_MEMORY)
    {
      int fd;
      ULONGEST addr;
      char mem_annex[32], lslr_annex[32];
      gdb_byte buf[32];
      ULONGEST lslr;
      enum target_xfer_status ret;

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

      /* Use the "mem" spufs file to access SPU local store.  */
      xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
      ret = spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len,
			       xfered_len);
      if (ret == TARGET_XFER_OK)
	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, xfered_len)
	  != TARGET_XFER_OK)
	return ret;

      lslr = strtoulst ((const char *) buf, NULL, 16);
      return spu_proc_xfer_spu (mem_annex, readbuf, writebuf,
				offset & lslr, len, xfered_len);
    }

  return TARGET_XFER_E_IO;
}

/* Override the to_can_use_hw_breakpoint routine.  */
static int
spu_can_use_hw_breakpoint (struct target_ops *self,
			   int type, int cnt, int othertype)
{
  return 0;
}

/* -Wmissing-prototypes */
extern initialize_file_ftype _initialize_spu_nat;

/* Initialize SPU native target.  */
void 
_initialize_spu_nat (void)
{
  /* Generic ptrace methods.  */
  struct target_ops *t;
  t = inf_ptrace_target ();

  /* Add SPU methods.  */
  t->to_post_attach = spu_child_post_attach;  
  t->to_post_startup_inferior = spu_child_post_startup_inferior;
  t->to_wait = spu_child_wait;
  t->to_fetch_registers = spu_fetch_inferior_registers;
  t->to_store_registers = spu_store_inferior_registers;
  t->to_xfer_partial = spu_xfer_partial;
  t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;

  /* Register SPU target.  */
  add_target (t);
}
Commit	Line	Data
771b4502	1	/* SPU native-dependent code for GDB, the GNU debugger.
ecd75fc8	2	Copyright (C) 2006-2014 Free Software Foundation, Inc.
771b4502 UW	3
	4	Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
771b4502 UW	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
771b4502 UW	20
	21	#include "defs.h"
	22	#include "gdbcore.h"
0e9f083f	23	#include <string.h>
771b4502 UW	24	#include "target.h"
771b4502 UW	25	#include "inferior.h"
dab06dbe	26	#include "inf-child.h"
771b4502 UW	27	#include "inf-ptrace.h"
	28	#include "regcache.h"
	29	#include "symfile.h"
	30	#include "gdb_wait.h"
d5b25491	31	#include "gdbthread.h"
92107356	32	#include "gdb_bfd.h"
771b4502 UW	33
	34	#include <sys/ptrace.h>
	35	#include <asm/ptrace.h>
	36	#include <sys/types.h>
771b4502 UW	37
	38	#include "spu-tdep.h"
	39
	40	/* PPU side system calls. */
	41	#define INSTR_SC 0x44000002
	42	#define NR_spu_run 0x0116
	43
	44
	45	/* Fetch PPU register REGNO. */
4179a487	46	static ULONGEST
771b4502 UW	47	fetch_ppc_register (int regno)
	48	{
	49	PTRACE_TYPE_RET res;
	50
dfd4cc63	51	int tid = ptid_get_lwp (inferior_ptid);
771b4502	52	if (tid == 0)
dfd4cc63	53	tid = ptid_get_pid (inferior_ptid);
771b4502 UW	54
	55	#ifndef __powerpc64__
	56	/* If running as a 32-bit process on a 64-bit system, we attempt
	57	to get the full 64-bit register content of the target process.
	58	If the PPC special ptrace call fails, we're on a 32-bit system;
	59	just fall through to the regular ptrace call in that case. */
	60	{
	61	gdb_byte buf[8];
	62
	63	errno = 0;
	64	ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
	65	(PTRACE_TYPE_ARG3) (regno * 8), buf);
	66	if (errno == 0)
	67	ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
	68	(PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
	69	if (errno == 0)
b9efddcd	70	return (ULONGEST) (uint64_t )buf;
771b4502 UW	71	}
	72	#endif
	73
	74	errno = 0;
	75	res = ptrace (PT_READ_U, tid,
	76	(PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
	77	if (errno != 0)
	78	{
	79	char mess[128];
	80	xsnprintf (mess, sizeof mess, "reading PPC register #%d", regno);
	81	perror_with_name (_(mess));
	82	}
	83
4179a487	84	return (ULONGEST) (unsigned long) res;
771b4502 UW	85	}
	86
	87	/* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
	88	static int
4179a487	89	fetch_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
771b4502 UW	90	{
	91	errno = 0;
	92
	93	#ifndef __powerpc64__
	94	if (memaddr >> 32)
	95	{
b9efddcd	96	uint64_t addr_8 = (uint64_t) memaddr;
771b4502 UW	97	ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
	98	}
	99	else
	100	#endif
	101	*word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
	102
	103	return errno;
	104	}
	105
	106	/* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
	107	static int
4179a487	108	store_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
771b4502 UW	109	{
	110	errno = 0;
	111
	112	#ifndef __powerpc64__
	113	if (memaddr >> 32)
	114	{
b9efddcd	115	uint64_t addr_8 = (uint64_t) memaddr;
771b4502 UW	116	ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
	117	}
	118	else
	119	#endif
	120	ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
	121
	122	return errno;
	123	}
	124
	125	/* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
	126	static int
4179a487	127	fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
771b4502 UW	128	{
	129	int i, ret;
	130
4179a487	131	ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
771b4502 UW	132	int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
	133	/ sizeof (PTRACE_TYPE_RET));
	134	PTRACE_TYPE_RET *buffer;
	135
dfd4cc63	136	int tid = ptid_get_lwp (inferior_ptid);
771b4502	137	if (tid == 0)
dfd4cc63	138	tid = ptid_get_pid (inferior_ptid);
771b4502 UW	139
	140	buffer = (PTRACE_TYPE_RET ) alloca (count sizeof (PTRACE_TYPE_RET));
	141	for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
b9efddcd UW	142	{
	143	ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
	144	if (ret)
	145	return ret;
	146	}
771b4502 UW	147
	148	memcpy (myaddr,
	149	(char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
	150	len);
	151
	152	return 0;
	153	}
	154
	155	/* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
	156	static int
4179a487	157	store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
771b4502 UW	158	{
	159	int i, ret;
	160
4179a487	161	ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
771b4502 UW	162	int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
	163	/ sizeof (PTRACE_TYPE_RET));
	164	PTRACE_TYPE_RET *buffer;
	165
dfd4cc63	166	int tid = ptid_get_lwp (inferior_ptid);
771b4502	167	if (tid == 0)
dfd4cc63	168	tid = ptid_get_pid (inferior_ptid);
771b4502 UW	169
	170	buffer = (PTRACE_TYPE_RET ) alloca (count sizeof (PTRACE_TYPE_RET));
	171
	172	if (addr != memaddr \|\| len < (int) sizeof (PTRACE_TYPE_RET))
b9efddcd UW	173	{
	174	ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
	175	if (ret)
	176	return ret;
	177	}
771b4502 UW	178
771b4502 UW	179	if (count > 1)
b9efddcd UW	180	{
b9efddcd UW	181	ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
771b4502	182	* sizeof (PTRACE_TYPE_RET),
b9efddcd UW	183	&buffer[count - 1]);
	184	if (ret)
	185	return ret;
	186	}
771b4502 UW	187
	188	memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
	189	myaddr, len);
	190
	191	for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
b9efddcd UW	192	{
	193	ret = store_ppc_memory_1 (tid, addr, buffer[i]);
	194	if (ret)
	195	return ret;
	196	}
771b4502 UW	197
	198	return 0;
	199	}
	200
	201
	202	/* If the PPU thread is currently stopped on a spu_run system call,
	203	return to FD and ADDR the file handle and NPC parameter address
	204	used with the system call. Return non-zero if successful. */
	205	static int
4179a487	206	parse_spufs_run (int fd, ULONGEST addr)
771b4502	207	{
f5656ead	208	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
771b4502	209	gdb_byte buf[4];
4179a487	210	ULONGEST pc = fetch_ppc_register (32); /* nip */
771b4502 UW	211
	212	/* Fetch instruction preceding current NIP. */
	213	if (fetch_ppc_memory (pc-4, buf, 4) != 0)
	214	return 0;
	215	/* It should be a "sc" instruction. */
e17a4113	216	if (extract_unsigned_integer (buf, 4, byte_order) != INSTR_SC)
771b4502 UW	217	return 0;
	218	/* System call number should be NR_spu_run. */
	219	if (fetch_ppc_register (0) != NR_spu_run)
	220	return 0;
	221
	222	/* Register 3 contains fd, register 4 the NPC param pointer. */
	223	fd = fetch_ppc_register (34); / orig_gpr3 */
	224	*addr = fetch_ppc_register (4);
	225	return 1;
	226	}
	227
	228
edcc890f YQ	229	/* Implement the to_xfer_partial target_ops method for TARGET_OBJECT_SPU.
edcc890f YQ	230	Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
771b4502	231	using the /proc file system. */
edcc890f	232
9b409511	233	static enum target_xfer_status
771b4502 UW	234	spu_proc_xfer_spu (const char annex, gdb_byte readbuf,
771b4502 UW	235	const gdb_byte *writebuf,
9b409511	236	ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
771b4502 UW	237	{
	238	char buf[128];
	239	int fd = 0;
	240	int ret = -1;
dfd4cc63	241	int pid = ptid_get_pid (inferior_ptid);
771b4502 UW	242
771b4502 UW	243	if (!annex)
9b409511	244	return TARGET_XFER_EOF;
771b4502 UW	245
	246	xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
	247	fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
	248	if (fd <= 0)
2ed4b548	249	return TARGET_XFER_E_IO;
771b4502 UW	250
	251	if (offset != 0
	252	&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
	253	{
	254	close (fd);
9b409511	255	return TARGET_XFER_EOF;
771b4502 UW	256	}
	257
	258	if (writebuf)
	259	ret = write (fd, writebuf, (size_t) len);
	260	else if (readbuf)
	261	ret = read (fd, readbuf, (size_t) len);
	262
	263	close (fd);
9b409511 YQ	264	if (ret < 0)
	265	return TARGET_XFER_E_IO;
	266	else if (ret == 0)
	267	return TARGET_XFER_EOF;
	268	else
	269	{
	270	*xfered_len = (ULONGEST) ret;
	271	return TARGET_XFER_OK;
	272	}
771b4502 UW	273	}
	274
	275
	276	/* Inferior memory should contain an SPE executable image at location ADDR.
	277	Allocate a BFD representing that executable. Return NULL on error. */
	278
	279	static void *
	280	spu_bfd_iovec_open (struct bfd nbfd, void open_closure)
	281	{
	282	return open_closure;
	283	}
	284
	285	static int
	286	spu_bfd_iovec_close (struct bfd nbfd, void stream)
	287	{
	288	xfree (stream);
39ed5604 JK	289
	290	/* Zero means success. */
	291	return 0;
771b4502 UW	292	}
	293
	294	static file_ptr
	295	spu_bfd_iovec_pread (struct bfd abfd, void stream, void *buf,
	296	file_ptr nbytes, file_ptr offset)
	297	{
4179a487	298	ULONGEST addr = (ULONGEST )stream;
771b4502 UW	299
	300	if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
	301	{
	302	bfd_set_error (bfd_error_invalid_operation);
	303	return -1;
	304	}
	305
	306	return nbytes;
	307	}
	308
f6cf9273 AM	309	static int
	310	spu_bfd_iovec_stat (struct bfd abfd, void stream, struct stat *sb)
	311	{
	312	/* We don't have an easy way of finding the size of embedded spu
	313	images. We could parse the in-memory ELF header and section
	314	table to find the extent of the last section but that seems
	315	pointless when the size is needed only for checks of other
	316	parsed values in dbxread.c. */
	317	sb->st_size = INT_MAX;
	318	return 0;
	319	}
	320
771b4502	321	static bfd *
4179a487	322	spu_bfd_open (ULONGEST addr)
771b4502 UW	323	{
771b4502 UW	324	struct bfd *nbfd;
9592c5d0	325	asection *spu_name;
771b4502	326
4179a487	327	ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
771b4502 UW	328	*open_closure = addr;
771b4502 UW	329
64c31149 TT	330	nbfd = gdb_bfd_openr_iovec ("<in-memory>", "elf32-spu",
	331	spu_bfd_iovec_open, open_closure,
	332	spu_bfd_iovec_pread, spu_bfd_iovec_close,
	333	spu_bfd_iovec_stat);
771b4502 UW	334	if (!nbfd)
	335	return NULL;
	336
	337	if (!bfd_check_format (nbfd, bfd_object))
	338	{
cbb099e8	339	gdb_bfd_unref (nbfd);
771b4502 UW	340	return NULL;
	341	}
	342
9592c5d0 UW	343	/* Retrieve SPU name note and update BFD name. */
	344	spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
	345	if (spu_name)
	346	{
	347	int sect_size = bfd_section_size (nbfd, spu_name);
	348	if (sect_size > 20)
	349	{
	350	char *buf = alloca (sect_size - 20 + 1);
	351	bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
	352	buf[sect_size - 20] = '\0';
	353
	354	xfree ((char *)nbfd->filename);
	355	nbfd->filename = xstrdup (buf);
	356	}
	357	}
	358
771b4502 UW	359	return nbfd;
	360	}
	361
	362	/* INFERIOR_FD is a file handle passed by the inferior to the
	363	spu_run system call. Assuming the SPE context was allocated
	364	by the libspe library, try to retrieve the main SPE executable
	365	file from its copy within the target process. */
	366	static void
	367	spu_symbol_file_add_from_memory (int inferior_fd)
	368	{
4179a487	369	ULONGEST addr;
771b4502 UW	370	struct bfd *nbfd;
771b4502 UW	371
22c90ac1	372	gdb_byte id[128];
771b4502	373	char annex[32];
9b409511 YQ	374	ULONGEST len;
9b409511 YQ	375	enum target_xfer_status status;
771b4502 UW	376
	377	/* Read object ID. */
	378	xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
9b409511 YQ	379	status = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id, &len);
9b409511 YQ	380	if (status != TARGET_XFER_OK \|\| len >= sizeof id)
771b4502 UW	381	return;
771b4502 UW	382	id[len] = 0;
22c90ac1	383	addr = strtoulst ((const char *) id, NULL, 16);
b9efddcd	384	if (!addr)
771b4502 UW	385	return;
	386
	387	/* Open BFD representing SPE executable and read its symbols. */
	388	nbfd = spu_bfd_open (addr);
	389	if (nbfd)
8ac244b4 TT	390	{
	391	struct cleanup *cleanup = make_cleanup_bfd_unref (nbfd);
	392
d64ad97c YQ	393	symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd),
d64ad97c YQ	394	SYMFILE_VERBOSE \| SYMFILE_MAINLINE,
8ac244b4 TT	395	NULL, 0, NULL);
	396	do_cleanups (cleanup);
	397	}
771b4502 UW	398	}
	399
	400
	401	/* Override the post_startup_inferior routine to continue running
	402	the inferior until the first spu_run system call. */
	403	static void
2e97a79e	404	spu_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
771b4502 UW	405	{
771b4502 UW	406	int fd;
4179a487	407	ULONGEST addr;
771b4502	408
dfd4cc63	409	int tid = ptid_get_lwp (ptid);
771b4502	410	if (tid == 0)
dfd4cc63	411	tid = ptid_get_pid (ptid);
771b4502 UW	412
	413	while (!parse_spufs_run (&fd, &addr))
	414	{
	415	ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
	416	waitpid (tid, NULL, __WALL \| __WNOTHREAD);
	417	}
	418	}
	419
	420	/* Override the post_attach routine to try load the SPE executable
	421	file image from its copy inside the target process. */
	422	static void
f045800c	423	spu_child_post_attach (struct target_ops *self, int pid)
771b4502 UW	424	{
771b4502 UW	425	int fd;
4179a487	426	ULONGEST addr;
771b4502 UW	427
	428	/* Like child_post_startup_inferior, if we happened to attach to
	429	the inferior while it wasn't currently in spu_run, continue
	430	running it until we get back there. */
	431	while (!parse_spufs_run (&fd, &addr))
	432	{
	433	ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
	434	waitpid (pid, NULL, __WALL \| __WNOTHREAD);
	435	}
	436
	437	/* If the user has not provided an executable file, try to extract
	438	the image from inside the target process. */
	439	if (!get_exec_file (0))
	440	spu_symbol_file_add_from_memory (fd);
	441	}
	442
	443	/* Wait for child PTID to do something. Return id of the child,
	444	minus_one_ptid in case of error; store status into OURSTATUS. /
	445	static ptid_t
117de6a9	446	spu_child_wait (struct target_ops *ops,
47608cb1	447	ptid_t ptid, struct target_waitstatus *ourstatus, int options)
771b4502 UW	448	{
	449	int save_errno;
	450	int status;
	451	pid_t pid;
	452
	453	do
	454	{
	455	set_sigint_trap (); /* Causes SIGINT to be passed on to the
	456	attached process. */
771b4502	457
dfd4cc63	458	pid = waitpid (ptid_get_pid (ptid), &status, 0);
771b4502 UW	459	if (pid == -1 && errno == ECHILD)
771b4502 UW	460	/* Try again with __WCLONE to check cloned processes. */
dfd4cc63	461	pid = waitpid (ptid_get_pid (ptid), &status, __WCLONE);
771b4502 UW	462
	463	save_errno = errno;
	464
	465	/* Make sure we don't report an event for the exit of the
	466	original program, if we've detached from it. */
dfd4cc63 LM	467	if (pid != -1 && !WIFSTOPPED (status)
dfd4cc63 LM	468	&& pid != ptid_get_pid (inferior_ptid))
771b4502 UW	469	{
	470	pid = -1;
	471	save_errno = EINTR;
	472	}
	473
771b4502 UW	474	clear_sigint_trap ();
	475	}
	476	while (pid == -1 && save_errno == EINTR);
	477
	478	if (pid == -1)
	479	{
b9efddcd	480	warning (_("Child process unexpectedly missing: %s"),
771b4502 UW	481	safe_strerror (save_errno));
	482
	483	/* Claim it exited with unknown signal. */
	484	ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
a493e3e2	485	ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
fb66883a	486	return inferior_ptid;
771b4502 UW	487	}
	488
	489	store_waitstatus (ourstatus, status);
	490	return pid_to_ptid (pid);
	491	}
	492
	493	/* Override the fetch_inferior_register routine. */
	494	static void
28439f5e PA	495	spu_fetch_inferior_registers (struct target_ops *ops,
28439f5e PA	496	struct regcache *regcache, int regno)
771b4502 UW	497	{
771b4502 UW	498	int fd;
4179a487	499	ULONGEST addr;
771b4502 UW	500
	501	/* We must be stopped on a spu_run system call. */
	502	if (!parse_spufs_run (&fd, &addr))
	503	return;
	504
	505	/* The ID register holds the spufs file handle. */
	506	if (regno == -1 \|\| regno == SPU_ID_REGNUM)
	507	{
e17a4113 UW	508	struct gdbarch *gdbarch = get_regcache_arch (regcache);
e17a4113 UW	509	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
e362b510	510	gdb_byte buf[4];
e17a4113	511	store_unsigned_integer (buf, 4, byte_order, fd);
56be3814	512	regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
771b4502 UW	513	}
	514
	515	/* The NPC register is found at ADDR. */
	516	if (regno == -1 \|\| regno == SPU_PC_REGNUM)
	517	{
	518	gdb_byte buf[4];
	519	if (fetch_ppc_memory (addr, buf, 4) == 0)
56be3814	520	regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
771b4502 UW	521	}
	522
	523	/* The GPRs are found in the "regs" spufs file. */
	524	if (regno == -1 \|\| (regno >= 0 && regno < SPU_NUM_GPRS))
	525	{
	526	gdb_byte buf[16 * SPU_NUM_GPRS];
	527	char annex[32];
	528	int i;
9b409511	529	ULONGEST len;
771b4502 UW	530
771b4502 UW	531	xsnprintf (annex, sizeof annex, "%d/regs", fd);
9b409511 YQ	532	if ((spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf, &len)
	533	== TARGET_XFER_OK)
	534	&& len == sizeof buf)
771b4502	535	for (i = 0; i < SPU_NUM_GPRS; i++)
56be3814	536	regcache_raw_supply (regcache, i, buf + i*16);
771b4502 UW	537	}
	538	}
	539
	540	/* Override the store_inferior_register routine. */
	541	static void
28439f5e PA	542	spu_store_inferior_registers (struct target_ops *ops,
28439f5e PA	543	struct regcache *regcache, int regno)
771b4502 UW	544	{
771b4502 UW	545	int fd;
4179a487	546	ULONGEST addr;
771b4502 UW	547
	548	/* We must be stopped on a spu_run system call. */
	549	if (!parse_spufs_run (&fd, &addr))
	550	return;
	551
	552	/* The NPC register is found at ADDR. */
	553	if (regno == -1 \|\| regno == SPU_PC_REGNUM)
	554	{
	555	gdb_byte buf[4];
56be3814	556	regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
771b4502 UW	557	store_ppc_memory (addr, buf, 4);
	558	}
	559
	560	/* The GPRs are found in the "regs" spufs file. */
	561	if (regno == -1 \|\| (regno >= 0 && regno < SPU_NUM_GPRS))
	562	{
	563	gdb_byte buf[16 * SPU_NUM_GPRS];
	564	char annex[32];
	565	int i;
9b409511	566	ULONGEST len;
771b4502 UW	567
771b4502 UW	568	for (i = 0; i < SPU_NUM_GPRS; i++)
56be3814	569	regcache_raw_collect (regcache, i, buf + i*16);
771b4502 UW	570
771b4502 UW	571	xsnprintf (annex, sizeof annex, "%d/regs", fd);
9b409511	572	spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf, &len);
771b4502 UW	573	}
	574	}
	575
	576	/* Override the to_xfer_partial routine. */
9b409511	577	static enum target_xfer_status
771b4502 UW	578	spu_xfer_partial (struct target_ops *ops,
	579	enum target_object object, const char *annex,
	580	gdb_byte readbuf, const gdb_byte writebuf,
9b409511	581	ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
771b4502	582	{
23d964e7	583	if (object == TARGET_OBJECT_SPU)
9b409511 YQ	584	return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len,
9b409511 YQ	585	xfered_len);
23d964e7	586
771b4502 UW	587	if (object == TARGET_OBJECT_MEMORY)
	588	{
	589	int fd;
4179a487	590	ULONGEST addr;
d2ed6730 UW	591	char mem_annex[32], lslr_annex[32];
	592	gdb_byte buf[32];
	593	ULONGEST lslr;
9b409511	594	enum target_xfer_status ret;
771b4502 UW	595
	596	/* We must be stopped on a spu_run system call. */
	597	if (!parse_spufs_run (&fd, &addr))
9b409511	598	return TARGET_XFER_EOF;
771b4502 UW	599
	600	/* Use the "mem" spufs file to access SPU local store. */
	601	xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
9b409511 YQ	602	ret = spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len,
	603	xfered_len);
	604	if (ret == TARGET_XFER_OK)
d2ed6730 UW	605	return ret;
	606
	607	/* SPU local store access wraps the address around at the
	608	local store limit. We emulate this here. To avoid needing
	609	an extra access to retrieve the LSLR, we only do that after
	610	trying the original address first, and getting end-of-file. */
	611	xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
	612	memset (buf, 0, sizeof buf);
9b409511 YQ	613	if (spu_proc_xfer_spu (lslr_annex, buf, NULL, 0, sizeof buf, xfered_len)
9b409511 YQ	614	!= TARGET_XFER_OK)
d2ed6730 UW	615	return ret;
d2ed6730 UW	616
22c90ac1	617	lslr = strtoulst ((const char *) buf, NULL, 16);
d2ed6730	618	return spu_proc_xfer_spu (mem_annex, readbuf, writebuf,
9b409511	619	offset & lslr, len, xfered_len);
771b4502 UW	620	}
771b4502 UW	621
2ed4b548	622	return TARGET_XFER_E_IO;
771b4502 UW	623	}
	624
	625	/* Override the to_can_use_hw_breakpoint routine. */
	626	static int
5461485a TT	627	spu_can_use_hw_breakpoint (struct target_ops *self,
5461485a TT	628	int type, int cnt, int othertype)
771b4502 UW	629	{
	630	return 0;
	631	}
	632
bd1f7788 YQ	633	/* -Wmissing-prototypes */
bd1f7788 YQ	634	extern initialize_file_ftype _initialize_spu_nat;
771b4502 UW	635
	636	/* Initialize SPU native target. */
	637	void
	638	_initialize_spu_nat (void)
	639	{
	640	/* Generic ptrace methods. */
	641	struct target_ops *t;
	642	t = inf_ptrace_target ();
	643
	644	/* Add SPU methods. */
	645	t->to_post_attach = spu_child_post_attach;
	646	t->to_post_startup_inferior = spu_child_post_startup_inferior;
	647	t->to_wait = spu_child_wait;
	648	t->to_fetch_registers = spu_fetch_inferior_registers;
	649	t->to_store_registers = spu_store_inferior_registers;
	650	t->to_xfer_partial = spu_xfer_partial;
	651	t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
	652
	653	/* Register SPU target. */
	654	add_target (t);
	655	}