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

/* SPU native-dependent code for GDB, the GNU debugger.
   Copyright (C) 2006-2013 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 "gdb_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 = TIDGET (inferior_ptid);
  if (tid == 0)
    tid = PIDGET (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 = TIDGET (inferior_ptid);
  if (tid == 0)
    tid = PIDGET (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 = TIDGET (inferior_ptid);
  if (tid == 0)
    tid = PIDGET (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;
}


/* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
   using the /proc file system.  */
static LONGEST
spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
		   const gdb_byte *writebuf,
		   ULONGEST offset, LONGEST len)
{
  char buf[128];
  int fd = 0;
  int ret = -1;
  int pid = PIDGET (inferior_ptid);

  if (!annex)
    return 0;

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

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

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

  close (fd);
  return ret;
}


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

  char id[128];
  char annex[32];
  int len;

  /* Read object ID.  */
  xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
  len = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id);
  if (len <= 0 || len >= sizeof id)
    return;
  id[len] = 0;
  addr = strtoulst (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, 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 (ptid_t ptid)
{
  int fd;
  ULONGEST addr;

  int tid = TIDGET (ptid);
  if (tid == 0)
    tid = PIDGET (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 (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 (PIDGET (ptid), &status, 0);
      if (pid == -1 && errno == ECHILD)
	/* Try again with __WCLONE to check cloned processes.  */
	pid = waitpid (PIDGET (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 != PIDGET (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;

      xsnprintf (annex, sizeof annex, "%d/regs", fd);
      if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == 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;

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

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

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

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

      /* 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);
      if (ret > 0)
	return ret;

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

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

  return -1;
}

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


/* 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.
28e7fd62	2	Copyright (C) 2006-2013 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"
	23	#include "gdb_string.h"
	24	#include "target.h"
	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
	51	int tid = TIDGET (inferior_ptid);
	52	if (tid == 0)
	53	tid = PIDGET (inferior_ptid);
	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
	136	int tid = TIDGET (inferior_ptid);
	137	if (tid == 0)
	138	tid = PIDGET (inferior_ptid);
	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
	166	int tid = TIDGET (inferior_ptid);
	167	if (tid == 0)
	168	tid = PIDGET (inferior_ptid);
	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
	229	/* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
	230	using the /proc file system. */
	231	static LONGEST
	232	spu_proc_xfer_spu (const char annex, gdb_byte readbuf,
	233	const gdb_byte *writebuf,
	234	ULONGEST offset, LONGEST len)
	235	{
	236	char buf[128];
	237	int fd = 0;
	238	int ret = -1;
	239	int pid = PIDGET (inferior_ptid);
	240
	241	if (!annex)
	242	return 0;
	243
	244	xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
	245	fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
	246	if (fd <= 0)
	247	return -1;
	248
	249	if (offset != 0
	250	&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
	251	{
	252	close (fd);
374c1d38	253	return 0;
771b4502 UW	254	}
	255
	256	if (writebuf)
	257	ret = write (fd, writebuf, (size_t) len);
	258	else if (readbuf)
	259	ret = read (fd, readbuf, (size_t) len);
	260
	261	close (fd);
	262	return ret;
	263	}
	264
	265
	266	/* Inferior memory should contain an SPE executable image at location ADDR.
	267	Allocate a BFD representing that executable. Return NULL on error. */
	268
	269	static void *
	270	spu_bfd_iovec_open (struct bfd nbfd, void open_closure)
	271	{
	272	return open_closure;
	273	}
	274
	275	static int
	276	spu_bfd_iovec_close (struct bfd nbfd, void stream)
	277	{
	278	xfree (stream);
39ed5604 JK	279
	280	/* Zero means success. */
	281	return 0;
771b4502 UW	282	}
	283
	284	static file_ptr
	285	spu_bfd_iovec_pread (struct bfd abfd, void stream, void *buf,
	286	file_ptr nbytes, file_ptr offset)
	287	{
4179a487	288	ULONGEST addr = (ULONGEST )stream;
771b4502 UW	289
	290	if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
	291	{
	292	bfd_set_error (bfd_error_invalid_operation);
	293	return -1;
	294	}
	295
	296	return nbytes;
	297	}
	298
f6cf9273 AM	299	static int
	300	spu_bfd_iovec_stat (struct bfd abfd, void stream, struct stat *sb)
	301	{
	302	/* We don't have an easy way of finding the size of embedded spu
	303	images. We could parse the in-memory ELF header and section
	304	table to find the extent of the last section but that seems
	305	pointless when the size is needed only for checks of other
	306	parsed values in dbxread.c. */
	307	sb->st_size = INT_MAX;
	308	return 0;
	309	}
	310
771b4502	311	static bfd *
4179a487	312	spu_bfd_open (ULONGEST addr)
771b4502 UW	313	{
771b4502 UW	314	struct bfd *nbfd;
9592c5d0	315	asection *spu_name;
771b4502	316
4179a487	317	ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
771b4502 UW	318	*open_closure = addr;
771b4502 UW	319
64c31149 TT	320	nbfd = gdb_bfd_openr_iovec ("<in-memory>", "elf32-spu",
	321	spu_bfd_iovec_open, open_closure,
	322	spu_bfd_iovec_pread, spu_bfd_iovec_close,
	323	spu_bfd_iovec_stat);
771b4502 UW	324	if (!nbfd)
	325	return NULL;
	326
	327	if (!bfd_check_format (nbfd, bfd_object))
	328	{
cbb099e8	329	gdb_bfd_unref (nbfd);
771b4502 UW	330	return NULL;
	331	}
	332
9592c5d0 UW	333	/* Retrieve SPU name note and update BFD name. */
	334	spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
	335	if (spu_name)
	336	{
	337	int sect_size = bfd_section_size (nbfd, spu_name);
	338	if (sect_size > 20)
	339	{
	340	char *buf = alloca (sect_size - 20 + 1);
	341	bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
	342	buf[sect_size - 20] = '\0';
	343
	344	xfree ((char *)nbfd->filename);
	345	nbfd->filename = xstrdup (buf);
	346	}
	347	}
	348
771b4502 UW	349	return nbfd;
	350	}
	351
	352	/* INFERIOR_FD is a file handle passed by the inferior to the
	353	spu_run system call. Assuming the SPE context was allocated
	354	by the libspe library, try to retrieve the main SPE executable
	355	file from its copy within the target process. */
	356	static void
	357	spu_symbol_file_add_from_memory (int inferior_fd)
	358	{
4179a487	359	ULONGEST addr;
771b4502 UW	360	struct bfd *nbfd;
	361
	362	char id[128];
	363	char annex[32];
	364	int len;
	365
	366	/* Read object ID. */
	367	xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
	368	len = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id);
	369	if (len <= 0 \|\| len >= sizeof id)
	370	return;
	371	id[len] = 0;
b9efddcd UW	372	addr = strtoulst (id, NULL, 16);
b9efddcd UW	373	if (!addr)
771b4502 UW	374	return;
	375
	376	/* Open BFD representing SPE executable and read its symbols. */
	377	nbfd = spu_bfd_open (addr);
	378	if (nbfd)
8ac244b4 TT	379	{
	380	struct cleanup *cleanup = make_cleanup_bfd_unref (nbfd);
	381
	382	symbol_file_add_from_bfd (nbfd, SYMFILE_VERBOSE \| SYMFILE_MAINLINE,
	383	NULL, 0, NULL);
	384	do_cleanups (cleanup);
	385	}
771b4502 UW	386	}
	387
	388
	389	/* Override the post_startup_inferior routine to continue running
	390	the inferior until the first spu_run system call. */
	391	static void
	392	spu_child_post_startup_inferior (ptid_t ptid)
	393	{
	394	int fd;
4179a487	395	ULONGEST addr;
771b4502 UW	396
	397	int tid = TIDGET (ptid);
	398	if (tid == 0)
	399	tid = PIDGET (ptid);
	400
	401	while (!parse_spufs_run (&fd, &addr))
	402	{
	403	ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
	404	waitpid (tid, NULL, __WALL \| __WNOTHREAD);
	405	}
	406	}
	407
	408	/* Override the post_attach routine to try load the SPE executable
	409	file image from its copy inside the target process. */
	410	static void
	411	spu_child_post_attach (int pid)
	412	{
	413	int fd;
4179a487	414	ULONGEST addr;
771b4502 UW	415
	416	/* Like child_post_startup_inferior, if we happened to attach to
	417	the inferior while it wasn't currently in spu_run, continue
	418	running it until we get back there. */
	419	while (!parse_spufs_run (&fd, &addr))
	420	{
	421	ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
	422	waitpid (pid, NULL, __WALL \| __WNOTHREAD);
	423	}
	424
	425	/* If the user has not provided an executable file, try to extract
	426	the image from inside the target process. */
	427	if (!get_exec_file (0))
	428	spu_symbol_file_add_from_memory (fd);
	429	}
	430
	431	/* Wait for child PTID to do something. Return id of the child,
	432	minus_one_ptid in case of error; store status into OURSTATUS. /
	433	static ptid_t
117de6a9	434	spu_child_wait (struct target_ops *ops,
47608cb1	435	ptid_t ptid, struct target_waitstatus *ourstatus, int options)
771b4502 UW	436	{
	437	int save_errno;
	438	int status;
	439	pid_t pid;
	440
	441	do
	442	{
	443	set_sigint_trap (); /* Causes SIGINT to be passed on to the
	444	attached process. */
771b4502 UW	445
	446	pid = waitpid (PIDGET (ptid), &status, 0);
	447	if (pid == -1 && errno == ECHILD)
	448	/* Try again with __WCLONE to check cloned processes. */
	449	pid = waitpid (PIDGET (ptid), &status, __WCLONE);
	450
	451	save_errno = errno;
	452
	453	/* Make sure we don't report an event for the exit of the
	454	original program, if we've detached from it. */
	455	if (pid != -1 && !WIFSTOPPED (status) && pid != PIDGET (inferior_ptid))
	456	{
	457	pid = -1;
	458	save_errno = EINTR;
	459	}
	460
771b4502 UW	461	clear_sigint_trap ();
	462	}
	463	while (pid == -1 && save_errno == EINTR);
	464
	465	if (pid == -1)
	466	{
b9efddcd	467	warning (_("Child process unexpectedly missing: %s"),
771b4502 UW	468	safe_strerror (save_errno));
	469
	470	/* Claim it exited with unknown signal. */
	471	ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
a493e3e2	472	ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
fb66883a	473	return inferior_ptid;
771b4502 UW	474	}
	475
	476	store_waitstatus (ourstatus, status);
	477	return pid_to_ptid (pid);
	478	}
	479
	480	/* Override the fetch_inferior_register routine. */
	481	static void
28439f5e PA	482	spu_fetch_inferior_registers (struct target_ops *ops,
28439f5e PA	483	struct regcache *regcache, int regno)
771b4502 UW	484	{
771b4502 UW	485	int fd;
4179a487	486	ULONGEST addr;
771b4502 UW	487
	488	/* We must be stopped on a spu_run system call. */
	489	if (!parse_spufs_run (&fd, &addr))
	490	return;
	491
	492	/* The ID register holds the spufs file handle. */
	493	if (regno == -1 \|\| regno == SPU_ID_REGNUM)
	494	{
e17a4113 UW	495	struct gdbarch *gdbarch = get_regcache_arch (regcache);
e17a4113 UW	496	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
e362b510	497	gdb_byte buf[4];
e17a4113	498	store_unsigned_integer (buf, 4, byte_order, fd);
56be3814	499	regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
771b4502 UW	500	}
	501
	502	/* The NPC register is found at ADDR. */
	503	if (regno == -1 \|\| regno == SPU_PC_REGNUM)
	504	{
	505	gdb_byte buf[4];
	506	if (fetch_ppc_memory (addr, buf, 4) == 0)
56be3814	507	regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
771b4502 UW	508	}
	509
	510	/* The GPRs are found in the "regs" spufs file. */
	511	if (regno == -1 \|\| (regno >= 0 && regno < SPU_NUM_GPRS))
	512	{
	513	gdb_byte buf[16 * SPU_NUM_GPRS];
	514	char annex[32];
	515	int i;
	516
	517	xsnprintf (annex, sizeof annex, "%d/regs", fd);
	518	if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
	519	for (i = 0; i < SPU_NUM_GPRS; i++)
56be3814	520	regcache_raw_supply (regcache, i, buf + i*16);
771b4502 UW	521	}
	522	}
	523
	524	/* Override the store_inferior_register routine. */
	525	static void
28439f5e PA	526	spu_store_inferior_registers (struct target_ops *ops,
28439f5e PA	527	struct regcache *regcache, int regno)
771b4502 UW	528	{
771b4502 UW	529	int fd;
4179a487	530	ULONGEST addr;
771b4502 UW	531
	532	/* We must be stopped on a spu_run system call. */
	533	if (!parse_spufs_run (&fd, &addr))
	534	return;
	535
	536	/* The NPC register is found at ADDR. */
	537	if (regno == -1 \|\| regno == SPU_PC_REGNUM)
	538	{
	539	gdb_byte buf[4];
56be3814	540	regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
771b4502 UW	541	store_ppc_memory (addr, buf, 4);
	542	}
	543
	544	/* The GPRs are found in the "regs" spufs file. */
	545	if (regno == -1 \|\| (regno >= 0 && regno < SPU_NUM_GPRS))
	546	{
	547	gdb_byte buf[16 * SPU_NUM_GPRS];
	548	char annex[32];
	549	int i;
	550
	551	for (i = 0; i < SPU_NUM_GPRS; i++)
56be3814	552	regcache_raw_collect (regcache, i, buf + i*16);
771b4502 UW	553
	554	xsnprintf (annex, sizeof annex, "%d/regs", fd);
	555	spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
	556	}
	557	}
	558
	559	/* Override the to_xfer_partial routine. */
	560	static LONGEST
	561	spu_xfer_partial (struct target_ops *ops,
	562	enum target_object object, const char *annex,
	563	gdb_byte readbuf, const gdb_byte writebuf,
	564	ULONGEST offset, LONGEST len)
	565	{
23d964e7 UW	566	if (object == TARGET_OBJECT_SPU)
	567	return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len);
	568
771b4502 UW	569	if (object == TARGET_OBJECT_MEMORY)
	570	{
	571	int fd;
4179a487	572	ULONGEST addr;
d2ed6730 UW	573	char mem_annex[32], lslr_annex[32];
	574	gdb_byte buf[32];
	575	ULONGEST lslr;
	576	LONGEST ret;
771b4502 UW	577
	578	/* We must be stopped on a spu_run system call. */
	579	if (!parse_spufs_run (&fd, &addr))
	580	return 0;
	581
	582	/* Use the "mem" spufs file to access SPU local store. */
	583	xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
d2ed6730 UW	584	ret = spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
	585	if (ret > 0)
	586	return ret;
	587
	588	/* SPU local store access wraps the address around at the
	589	local store limit. We emulate this here. To avoid needing
	590	an extra access to retrieve the LSLR, we only do that after
	591	trying the original address first, and getting end-of-file. */
	592	xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
	593	memset (buf, 0, sizeof buf);
	594	if (spu_proc_xfer_spu (lslr_annex, buf, NULL, 0, sizeof buf) <= 0)
	595	return ret;
	596
	597	lslr = strtoulst (buf, NULL, 16);
	598	return spu_proc_xfer_spu (mem_annex, readbuf, writebuf,
	599	offset & lslr, len);
771b4502 UW	600	}
771b4502 UW	601
9dea8ca2	602	return -1;
771b4502 UW	603	}
	604
	605	/* Override the to_can_use_hw_breakpoint routine. */
	606	static int
	607	spu_can_use_hw_breakpoint (int type, int cnt, int othertype)
	608	{
	609	return 0;
	610	}
	611
	612
	613	/* Initialize SPU native target. */
	614	void
	615	_initialize_spu_nat (void)
	616	{
	617	/* Generic ptrace methods. */
	618	struct target_ops *t;
	619	t = inf_ptrace_target ();
	620
	621	/* Add SPU methods. */
	622	t->to_post_attach = spu_child_post_attach;
	623	t->to_post_startup_inferior = spu_child_post_startup_inferior;
	624	t->to_wait = spu_child_wait;
	625	t->to_fetch_registers = spu_fetch_inferior_registers;
	626	t->to_store_registers = spu_store_inferior_registers;
	627	t->to_xfer_partial = spu_xfer_partial;
	628	t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
	629
	630	/* Register SPU target. */
	631	add_target (t);
	632	}