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

/* Low level interface to SPUs, for the remote server for GDB.
   Copyright (C) 2006-2012 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 "server.h"

#include "gdb_wait.h"
#include <stdio.h>
#include <sys/ptrace.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/syscall.h>

/* Some older glibc versions do not define this.  */
#ifndef __WNOTHREAD
#define __WNOTHREAD     0x20000000      /* Don't wait on children of other
					   threads in this group */
#endif

#define PTRACE_TYPE_RET long
#define PTRACE_TYPE_ARG3 long

/* Number of registers.  */
#define SPU_NUM_REGS         130
#define SPU_NUM_CORE_REGS    128

/* Special registers.  */
#define SPU_ID_REGNUM        128
#define SPU_PC_REGNUM        129

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

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

/* Defined in auto-generated file reg-spu.c.  */
void init_registers_spu (void);


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

  int tid = ptid_get_lwp (current_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.  */
  {
    char 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 (CORE_ADDR) *(unsigned long long *)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];
      sprintf (mess, "reading PPC register #%d", regno);
      perror_with_name (mess);
    }

  return (CORE_ADDR) (unsigned long) res;
}

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

#ifndef __powerpc64__
  if (memaddr >> 32)
    {
      unsigned long long addr_8 = (unsigned long long) 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, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
{
  errno = 0;

#ifndef __powerpc64__
  if (memaddr >> 32)
    {
      unsigned long long addr_8 = (unsigned long long) 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 (CORE_ADDR memaddr, char *myaddr, int len)
{
  int i, ret;

  CORE_ADDR addr = memaddr & -(CORE_ADDR) 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 (current_ptid);

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

  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 (CORE_ADDR memaddr, char *myaddr, int len)
{
  int i, ret;

  CORE_ADDR addr = memaddr & -(CORE_ADDR) 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 (current_ptid);

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

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

  if (count > 1)
    if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
					       * sizeof (PTRACE_TYPE_RET),
				   &buffer[count - 1])) != 0)
      return ret;

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

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

  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, CORE_ADDR *addr)
{
  unsigned int insn;
  CORE_ADDR pc = fetch_ppc_register (32);  /* nip */

  /* Fetch instruction preceding current NIP.  */
  if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
    return 0;
  /* It should be a "sc" instruction.  */
  if (insn != 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 int
spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
		   const unsigned char *writebuf,
		   CORE_ADDR offset, int len)
{
  char buf[128];
  int fd = 0;
  int ret = -1;

  if (!annex)
    return 0;

  sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
  fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
  if (fd <= 0)
    return -1;

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


/* Start an inferior process and returns its pid.
   ALLARGS is a vector of program-name and args. */
static int
spu_create_inferior (char *program, char **allargs)
{
  int pid;
  ptid_t ptid;

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

  if (pid == 0)
    {
      ptrace (PTRACE_TRACEME, 0, 0, 0);

      setpgid (0, 0);

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

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

  add_process (pid, 0);

  ptid = ptid_build (pid, pid, 0);
  add_thread (ptid, NULL);
  return pid;
}

/* Attach to an inferior process.  */
int
spu_attach (unsigned long  pid)
{
  ptid_t ptid;

  if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
    {
      fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
	       strerror (errno), errno);
      fflush (stderr);
      _exit (0177);
    }

  add_process (pid, 1);
  ptid = ptid_build (pid, pid, 0);
  add_thread (ptid, NULL);
  return 0;
}

/* Kill the inferior process.  */
static int
spu_kill (int pid)
{
  int status, ret;
  struct process_info *process = find_process_pid (pid);
  if (process == NULL)
    return -1;

  ptrace (PTRACE_KILL, pid, 0, 0);

  do {
    ret = waitpid (pid, &status, 0);
    if (WIFEXITED (status) || WIFSIGNALED (status))
      break;
  } while (ret != -1 || errno != ECHILD);

  clear_inferiors ();
  remove_process (process);
  return 0;
}

/* Detach from inferior process.  */
static int
spu_detach (int pid)
{
  struct process_info *process = find_process_pid (pid);
  if (process == NULL)
    return -1;

  ptrace (PTRACE_DETACH, pid, 0, 0);

  clear_inferiors ();
  remove_process (process);
  return 0;
}

static void
spu_mourn (struct process_info *process)
{
  remove_process (process);
}

static void
spu_join (int pid)
{
  int status, ret;

  do {
    ret = waitpid (pid, &status, 0);
    if (WIFEXITED (status) || WIFSIGNALED (status))
      break;
  } while (ret != -1 || errno != ECHILD);
}

/* Return nonzero if the given thread is still alive.  */
static int
spu_thread_alive (ptid_t ptid)
{
  return ptid_equal (ptid, current_ptid);
}

/* Resume process.  */
static void
spu_resume (struct thread_resume *resume_info, size_t n)
{
  size_t i;

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

  if (i == n)
    return;

  /* We don't support hardware single-stepping right now, assume
     GDB knows to use software single-stepping.  */
  if (resume_info[i].kind == resume_step)
    fprintf (stderr, "Hardware single-step not supported.\n");

  regcache_invalidate ();

  errno = 0;
  ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig);
  if (errno)
    perror_with_name ("ptrace");
}

/* Wait for process, returns status.  */
static ptid_t
spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
{
  int pid = ptid_get_pid (ptid);
  int w;
  int ret;

  while (1)
    {
      ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);

      if (ret == -1)
	{
	  if (errno != ECHILD)
	    perror_with_name ("waitpid");
	}
      else if (ret > 0)
	break;

      usleep (1000);
    }

  /* On the first wait, continue running the inferior until we are
     blocked inside an spu_run system call.  */
  if (!server_waiting)
    {
      int fd;
      CORE_ADDR addr;

      while (!parse_spufs_run (&fd, &addr))
	{
	  ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
	  waitpid (pid, NULL, __WALL | __WNOTHREAD);
	}
    }

  if (WIFEXITED (w))
    {
      fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
      ourstatus->kind =  TARGET_WAITKIND_EXITED;
      ourstatus->value.integer = WEXITSTATUS (w);
      clear_inferiors ();
      return pid_to_ptid (ret);
    }
  else if (!WIFSTOPPED (w))
    {
      fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
      ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
      ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
      clear_inferiors ();
      return pid_to_ptid (ret);
    }

  /* After attach, we may have received a SIGSTOP.  Do not return this
     as signal to GDB, or else it will try to continue with SIGSTOP ...  */
  if (!server_waiting)
    {
      ourstatus->kind = TARGET_WAITKIND_STOPPED;
      ourstatus->value.sig = GDB_SIGNAL_0;
      return ptid_build (ret, ret, 0);
    }

  ourstatus->kind = TARGET_WAITKIND_STOPPED;
  ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
  return ptid_build (ret, ret, 0);
}

/* Fetch inferior registers.  */
static void
spu_fetch_registers (struct regcache *regcache, int regno)
{
  int fd;
  CORE_ADDR 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)
    supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);

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

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

      sprintf (annex, "%d/regs", fd);
      if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
	for (i = 0; i < SPU_NUM_CORE_REGS; i++)
	  supply_register (regcache, i, buf + i*16);
    }
}

/* Store inferior registers.  */
static void
spu_store_registers (struct regcache *regcache, int regno)
{
  int fd;
  CORE_ADDR addr;

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

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

  /* The NPC register is found at ADDR.  */
  if (regno == -1 || regno == SPU_PC_REGNUM)
    {
      char buf[4];
      collect_register (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_CORE_REGS))
    {
      unsigned char buf[16*SPU_NUM_CORE_REGS];
      char annex[32];
      int i;

      for (i = 0; i < SPU_NUM_CORE_REGS; i++)
	collect_register (regcache, i, buf + i*16);

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

/* Copy LEN bytes from inferior's memory starting at MEMADDR
   to debugger memory starting at MYADDR.  */
static int
spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
{
  int fd, ret;
  CORE_ADDR addr;
  char annex[32], lslr_annex[32], buf[32];
  CORE_ADDR lslr;

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

  /* Use the "mem" spufs file to access SPU local store.  */
  sprintf (annex, "%d/mem", fd);
  ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
  if (ret > 0)
    return ret == len ? 0 : EIO;

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

  lslr = strtoul (buf, NULL, 16);
  ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);

  return ret == len ? 0 : EIO;
}

/* Copy LEN bytes of data from debugger memory at MYADDR
   to inferior's memory at MEMADDR.
   On failure (cannot write the inferior)
   returns the value of errno.  */
static int
spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
{
  int fd, ret;
  CORE_ADDR addr;
  char annex[32], lslr_annex[32], buf[32];
  CORE_ADDR lslr;

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

  /* Use the "mem" spufs file to access SPU local store.  */
  sprintf (annex, "%d/mem", fd);
  ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
  if (ret > 0)
    return ret == len ? 0 : EIO;

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

  lslr = strtoul (buf, NULL, 16);
  ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);

  return ret == len ? 0 : EIO;
}

/* Look up special symbols -- unneded here.  */
static void
spu_look_up_symbols (void)
{
}

/* Send signal to inferior.  */
static void
spu_request_interrupt (void)
{
  syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);
}

static struct target_ops spu_target_ops = {
  spu_create_inferior,
  spu_attach,
  spu_kill,
  spu_detach,
  spu_mourn,
  spu_join,
  spu_thread_alive,
  spu_resume,
  spu_wait,
  spu_fetch_registers,
  spu_store_registers,
  NULL, /* prepare_to_access_memory */
  NULL, /* done_accessing_memory */
  spu_read_memory,
  spu_write_memory,
  spu_look_up_symbols,
  spu_request_interrupt,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  spu_proc_xfer_spu,
  hostio_last_error_from_errno,
};

void
initialize_low (void)
{
  static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };

  set_target_ops (&spu_target_ops);
  set_breakpoint_data (breakpoint, sizeof breakpoint);
  init_registers_spu ();
}
Commit	Line	Data
a13e2c95	1	/* Low level interface to SPUs, for the remote server for GDB.
0b302171	2	Copyright (C) 2006-2012 Free Software Foundation, Inc.
a13e2c95 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
a13e2c95 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/>. */
a13e2c95 UW	20
	21	#include "server.h"
	22
8bdce1ff	23	#include "gdb_wait.h"
a13e2c95 UW	24	#include <stdio.h>
	25	#include <sys/ptrace.h>
	26	#include <fcntl.h>
	27	#include <string.h>
	28	#include <stdlib.h>
	29	#include <unistd.h>
	30	#include <errno.h>
	31	#include <sys/syscall.h>
	32
	33	/* Some older glibc versions do not define this. */
	34	#ifndef __WNOTHREAD
	35	#define __WNOTHREAD 0x20000000 /* Don't wait on children of other
1b3f6016	36	threads in this group */
a13e2c95 UW	37	#endif
	38
	39	#define PTRACE_TYPE_RET long
	40	#define PTRACE_TYPE_ARG3 long
	41
	42	/* Number of registers. */
	43	#define SPU_NUM_REGS 130
	44	#define SPU_NUM_CORE_REGS 128
	45
	46	/* Special registers. */
	47	#define SPU_ID_REGNUM 128
	48	#define SPU_PC_REGNUM 129
	49
	50	/* PPU side system calls. */
	51	#define INSTR_SC 0x44000002
	52	#define NR_spu_run 0x0116
	53
a13e2c95 UW	54	/* These are used in remote-utils.c. */
a13e2c95 UW	55	int using_threads = 0;
a13e2c95	56
d05b4ac3 UW	57	/* Defined in auto-generated file reg-spu.c. */
	58	void init_registers_spu (void);
	59
a13e2c95 UW	60
	61	/* Fetch PPU register REGNO. */
	62	static CORE_ADDR
	63	fetch_ppc_register (int regno)
	64	{
	65	PTRACE_TYPE_RET res;
	66
5472f405	67	int tid = ptid_get_lwp (current_ptid);
a13e2c95 UW	68
	69	#ifndef __powerpc64__
	70	/* If running as a 32-bit process on a 64-bit system, we attempt
	71	to get the full 64-bit register content of the target process.
	72	If the PPC special ptrace call fails, we're on a 32-bit system;
	73	just fall through to the regular ptrace call in that case. */
	74	{
	75	char buf[8];
	76
	77	errno = 0;
	78	ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
	79	(PTRACE_TYPE_ARG3) (regno * 8), buf);
	80	if (errno == 0)
	81	ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
	82	(PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
	83	if (errno == 0)
	84	return (CORE_ADDR) (unsigned long long )buf;
	85	}
	86	#endif
	87
	88	errno = 0;
	89	res = ptrace (PT_READ_U, tid,
1b3f6016	90	(PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
a13e2c95 UW	91	if (errno != 0)
	92	{
	93	char mess[128];
	94	sprintf (mess, "reading PPC register #%d", regno);
	95	perror_with_name (mess);
	96	}
	97
	98	return (CORE_ADDR) (unsigned long) res;
	99	}
	100
	101	/* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
	102	static int
	103	fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
	104	{
	105	errno = 0;
	106
	107	#ifndef __powerpc64__
	108	if (memaddr >> 32)
	109	{
	110	unsigned long long addr_8 = (unsigned long long) memaddr;
	111	ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
	112	}
	113	else
	114	#endif
	115	*word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
	116
	117	return errno;
	118	}
	119
	120	/* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
	121	static int
	122	store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
	123	{
	124	errno = 0;
	125
	126	#ifndef __powerpc64__
	127	if (memaddr >> 32)
	128	{
	129	unsigned long long addr_8 = (unsigned long long) memaddr;
	130	ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
	131	}
	132	else
	133	#endif
	134	ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
	135
	136	return errno;
	137	}
	138
	139	/* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
	140	static int
	141	fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
	142	{
	143	int i, ret;
	144
	145	CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
	146	int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
	147	/ sizeof (PTRACE_TYPE_RET));
	148	PTRACE_TYPE_RET *buffer;
	149
5472f405	150	int tid = ptid_get_lwp (current_ptid);
a13e2c95 UW	151
	152	buffer = (PTRACE_TYPE_RET ) alloca (count sizeof (PTRACE_TYPE_RET));
	153	for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
	154	if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
	155	return ret;
	156
	157	memcpy (myaddr,
	158	(char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
	159	len);
	160
	161	return 0;
	162	}
	163
	164	/* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
	165	static int
	166	store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
	167	{
	168	int i, ret;
	169
	170	CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
	171	int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
	172	/ sizeof (PTRACE_TYPE_RET));
	173	PTRACE_TYPE_RET *buffer;
	174
5472f405	175	int tid = ptid_get_lwp (current_ptid);
a13e2c95 UW	176
	177	buffer = (PTRACE_TYPE_RET ) alloca (count sizeof (PTRACE_TYPE_RET));
	178
	179	if (addr != memaddr \|\| len < (int) sizeof (PTRACE_TYPE_RET))
	180	if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
	181	return ret;
	182
	183	if (count > 1)
	184	if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
	185	* sizeof (PTRACE_TYPE_RET),
	186	&buffer[count - 1])) != 0)
	187	return ret;
	188
	189	memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
1b3f6016	190	myaddr, len);
a13e2c95 UW	191
	192	for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
	193	if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
	194	return ret;
	195
	196	return 0;
	197	}
	198
	199
	200	/* If the PPU thread is currently stopped on a spu_run system call,
	201	return to FD and ADDR the file handle and NPC parameter address
	202	used with the system call. Return non-zero if successful. */
1b3f6016	203	static int
a13e2c95 UW	204	parse_spufs_run (int fd, CORE_ADDR addr)
a13e2c95 UW	205	{
9d236627	206	unsigned int insn;
a13e2c95 UW	207	CORE_ADDR pc = fetch_ppc_register (32); /* nip */
	208
	209	/* Fetch instruction preceding current NIP. */
9d236627	210	if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
a13e2c95 UW	211	return 0;
a13e2c95 UW	212	/* It should be a "sc" instruction. */
9d236627	213	if (insn != INSTR_SC)
a13e2c95 UW	214	return 0;
	215	/* System call number should be NR_spu_run. */
	216	if (fetch_ppc_register (0) != NR_spu_run)
	217	return 0;
	218
	219	/* Register 3 contains fd, register 4 the NPC param pointer. */
	220	fd = fetch_ppc_register (34); / orig_gpr3 */
	221	*addr = fetch_ppc_register (4);
	222	return 1;
	223	}
	224
	225
	226	/* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
	227	using the /proc file system. */
	228	static int
	229	spu_proc_xfer_spu (const char annex, unsigned char readbuf,
	230	const unsigned char *writebuf,
	231	CORE_ADDR offset, int len)
	232	{
	233	char buf[128];
	234	int fd = 0;
	235	int ret = -1;
	236
	237	if (!annex)
	238	return 0;
	239
5472f405	240	sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
a13e2c95 UW	241	fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
	242	if (fd <= 0)
	243	return -1;
	244
	245	if (offset != 0
	246	&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
	247	{
	248	close (fd);
374c1d38	249	return 0;
a13e2c95 UW	250	}
	251
	252	if (writebuf)
	253	ret = write (fd, writebuf, (size_t) len);
	254	else if (readbuf)
	255	ret = read (fd, readbuf, (size_t) len);
	256
	257	close (fd);
	258	return ret;
	259	}
	260
	261
	262	/* Start an inferior process and returns its pid.
	263	ALLARGS is a vector of program-name and args. */
	264	static int
	265	spu_create_inferior (char program, char *allargs)
	266	{
	267	int pid;
95954743	268	ptid_t ptid;
a13e2c95 UW	269
	270	pid = fork ();
	271	if (pid < 0)
	272	perror_with_name ("fork");
	273
	274	if (pid == 0)
	275	{
	276	ptrace (PTRACE_TRACEME, 0, 0, 0);
	277
	278	setpgid (0, 0);
	279
2b876972 DJ	280	execv (program, allargs);
	281	if (errno == ENOENT)
	282	execvp (program, allargs);
a13e2c95 UW	283
	284	fprintf (stderr, "Cannot exec %s: %s.\n", program,
	285	strerror (errno));
	286	fflush (stderr);
	287	_exit (0177);
	288	}
	289
95954743 PA	290	add_process (pid, 0);
	291
	292	ptid = ptid_build (pid, pid, 0);
	293	add_thread (ptid, NULL);
a13e2c95 UW	294	return pid;
	295	}
	296
	297	/* Attach to an inferior process. */
	298	int
	299	spu_attach (unsigned long pid)
	300	{
95954743 PA	301	ptid_t ptid;
95954743 PA	302
a13e2c95 UW	303	if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
	304	{
	305	fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
	306	strerror (errno), errno);
	307	fflush (stderr);
	308	_exit (0177);
	309	}
	310
95954743 PA	311	add_process (pid, 1);
	312	ptid = ptid_build (pid, pid, 0);
	313	add_thread (ptid, NULL);
a13e2c95 UW	314	return 0;
	315	}
	316
	317	/* Kill the inferior process. */
95954743	318	static int
5472f405	319	spu_kill (int pid)
a13e2c95	320	{
4168d2d6	321	int status, ret;
5472f405 UW	322	struct process_info *process = find_process_pid (pid);
	323	if (process == NULL)
	324	return -1;
	325
	326	ptrace (PTRACE_KILL, pid, 0, 0);
4168d2d6 UW	327
	328	do {
	329	ret = waitpid (pid, &status, 0);
	330	if (WIFEXITED (status) \|\| WIFSIGNALED (status))
	331	break;
	332	} while (ret != -1 \|\| errno != ECHILD);
	333
	334	clear_inferiors ();
5472f405	335	remove_process (process);
95954743	336	return 0;
a13e2c95 UW	337	}
	338
	339	/* Detach from inferior process. */
dd6953e1	340	static int
95954743	341	spu_detach (int pid)
a13e2c95	342	{
5472f405 UW	343	struct process_info *process = find_process_pid (pid);
	344	if (process == NULL)
	345	return -1;
	346
	347	ptrace (PTRACE_DETACH, pid, 0, 0);
4168d2d6 UW	348
4168d2d6 UW	349	clear_inferiors ();
5472f405	350	remove_process (process);
dd6953e1	351	return 0;
a13e2c95 UW	352	}
a13e2c95 UW	353
505106cd PA	354	static void
	355	spu_mourn (struct process_info *process)
	356	{
	357	remove_process (process);
	358	}
	359
444d6139	360	static void
95954743	361	spu_join (int pid)
444d6139 PA	362	{
	363	int status, ret;
	364
	365	do {
5472f405	366	ret = waitpid (pid, &status, 0);
444d6139 PA	367	if (WIFEXITED (status) \|\| WIFSIGNALED (status))
	368	break;
	369	} while (ret != -1 \|\| errno != ECHILD);
	370	}
	371
a13e2c95 UW	372	/* Return nonzero if the given thread is still alive. */
a13e2c95 UW	373	static int
95954743	374	spu_thread_alive (ptid_t ptid)
a13e2c95	375	{
5472f405	376	return ptid_equal (ptid, current_ptid);
a13e2c95 UW	377	}
	378
	379	/* Resume process. */
	380	static void
2bd7c093	381	spu_resume (struct thread_resume *resume_info, size_t n)
a13e2c95	382	{
2bd7c093	383	size_t i;
a13e2c95	384
2bd7c093	385	for (i = 0; i < n; i++)
95954743	386	if (ptid_equal (resume_info[i].thread, minus_one_ptid)
5472f405	387	\|\| ptid_equal (resume_info[i].thread, current_ptid))
2bd7c093 PA	388	break;
	389
	390	if (i == n)
a13e2c95 UW	391	return;
	392
	393	/* We don't support hardware single-stepping right now, assume
	394	GDB knows to use software single-stepping. */
bd99dc85	395	if (resume_info[i].kind == resume_step)
a13e2c95 UW	396	fprintf (stderr, "Hardware single-step not supported.\n");
	397
	398	regcache_invalidate ();
	399
	400	errno = 0;
5472f405	401	ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig);
a13e2c95 UW	402	if (errno)
	403	perror_with_name ("ptrace");
	404	}
	405
	406	/* Wait for process, returns status. */
95954743 PA	407	static ptid_t
95954743 PA	408	spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
a13e2c95	409	{
5472f405	410	int pid = ptid_get_pid (ptid);
a13e2c95 UW	411	int w;
	412	int ret;
	413
a13e2c95 UW	414	while (1)
a13e2c95 UW	415	{
5472f405	416	ret = waitpid (pid, &w, WNOHANG \| __WALL \| __WNOTHREAD);
a13e2c95 UW	417
	418	if (ret == -1)
	419	{
	420	if (errno != ECHILD)
	421	perror_with_name ("waitpid");
	422	}
	423	else if (ret > 0)
	424	break;
	425
	426	usleep (1000);
	427	}
	428
	429	/* On the first wait, continue running the inferior until we are
	430	blocked inside an spu_run system call. */
	431	if (!server_waiting)
	432	{
	433	int fd;
	434	CORE_ADDR addr;
	435
	436	while (!parse_spufs_run (&fd, &addr))
	437	{
5472f405 UW	438	ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
5472f405 UW	439	waitpid (pid, NULL, __WALL \| __WNOTHREAD);
a13e2c95 UW	440	}
	441	}
	442
a13e2c95 UW	443	if (WIFEXITED (w))
	444	{
	445	fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
5b1c542e PA	446	ourstatus->kind = TARGET_WAITKIND_EXITED;
5b1c542e PA	447	ourstatus->value.integer = WEXITSTATUS (w);
a13e2c95	448	clear_inferiors ();
95954743	449	return pid_to_ptid (ret);
a13e2c95 UW	450	}
	451	else if (!WIFSTOPPED (w))
	452	{
	453	fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
5b1c542e	454	ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2ea28649	455	ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
a13e2c95	456	clear_inferiors ();
95954743	457	return pid_to_ptid (ret);
a13e2c95 UW	458	}
	459
	460	/* After attach, we may have received a SIGSTOP. Do not return this
	461	as signal to GDB, or else it will try to continue with SIGSTOP ... */
	462	if (!server_waiting)
	463	{
5b1c542e	464	ourstatus->kind = TARGET_WAITKIND_STOPPED;
a493e3e2	465	ourstatus->value.sig = GDB_SIGNAL_0;
95954743	466	return ptid_build (ret, ret, 0);
a13e2c95 UW	467	}
a13e2c95 UW	468
5b1c542e	469	ourstatus->kind = TARGET_WAITKIND_STOPPED;
2ea28649	470	ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
95954743	471	return ptid_build (ret, ret, 0);
a13e2c95 UW	472	}
	473
	474	/* Fetch inferior registers. */
	475	static void
85492558	476	spu_fetch_registers (struct regcache *regcache, int regno)
a13e2c95 UW	477	{
	478	int fd;
	479	CORE_ADDR addr;
	480
a13e2c95 UW	481	/* We must be stopped on a spu_run system call. */
	482	if (!parse_spufs_run (&fd, &addr))
	483	return;
	484
	485	/* The ID register holds the spufs file handle. */
	486	if (regno == -1 \|\| regno == SPU_ID_REGNUM)
85492558	487	supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
a13e2c95 UW	488
	489	/* The NPC register is found at ADDR. */
	490	if (regno == -1 \|\| regno == SPU_PC_REGNUM)
	491	{
	492	char buf[4];
	493	if (fetch_ppc_memory (addr, buf, 4) == 0)
85492558	494	supply_register (regcache, SPU_PC_REGNUM, buf);
a13e2c95 UW	495	}
	496
	497	/* The GPRs are found in the "regs" spufs file. */
	498	if (regno == -1 \|\| (regno >= 0 && regno < SPU_NUM_CORE_REGS))
	499	{
	500	unsigned char buf[16*SPU_NUM_CORE_REGS];
	501	char annex[32];
	502	int i;
	503
	504	sprintf (annex, "%d/regs", fd);
	505	if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
	506	for (i = 0; i < SPU_NUM_CORE_REGS; i++)
85492558	507	supply_register (regcache, i, buf + i*16);
a13e2c95 UW	508	}
	509	}
	510
	511	/* Store inferior registers. */
	512	static void
85492558	513	spu_store_registers (struct regcache *regcache, int regno)
a13e2c95 UW	514	{
	515	int fd;
	516	CORE_ADDR addr;
	517
	518	/* ??? Some callers use 0 to mean all registers. */
	519	if (regno == 0)
	520	regno = -1;
	521
	522	/* We must be stopped on a spu_run system call. */
	523	if (!parse_spufs_run (&fd, &addr))
	524	return;
	525
	526	/* The NPC register is found at ADDR. */
	527	if (regno == -1 \|\| regno == SPU_PC_REGNUM)
	528	{
	529	char buf[4];
85492558	530	collect_register (regcache, SPU_PC_REGNUM, buf);
a13e2c95 UW	531	store_ppc_memory (addr, buf, 4);
	532	}
	533
	534	/* The GPRs are found in the "regs" spufs file. */
	535	if (regno == -1 \|\| (regno >= 0 && regno < SPU_NUM_CORE_REGS))
	536	{
	537	unsigned char buf[16*SPU_NUM_CORE_REGS];
	538	char annex[32];
	539	int i;
	540
	541	for (i = 0; i < SPU_NUM_CORE_REGS; i++)
85492558	542	collect_register (regcache, i, buf + i*16);
a13e2c95 UW	543
	544	sprintf (annex, "%d/regs", fd);
	545	spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
	546	}
	547	}
	548
	549	/* Copy LEN bytes from inferior's memory starting at MEMADDR
	550	to debugger memory starting at MYADDR. */
	551	static int
	552	spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
	553	{
	554	int fd, ret;
	555	CORE_ADDR addr;
d2ed6730 UW	556	char annex[32], lslr_annex[32], buf[32];
d2ed6730 UW	557	CORE_ADDR lslr;
a13e2c95 UW	558
	559	/* We must be stopped on a spu_run system call. */
	560	if (!parse_spufs_run (&fd, &addr))
	561	return 0;
	562
	563	/* Use the "mem" spufs file to access SPU local store. */
	564	sprintf (annex, "%d/mem", fd);
	565	ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
d2ed6730 UW	566	if (ret > 0)
	567	return ret == len ? 0 : EIO;
	568
	569	/* SPU local store access wraps the address around at the
	570	local store limit. We emulate this here. To avoid needing
	571	an extra access to retrieve the LSLR, we only do that after
	572	trying the original address first, and getting end-of-file. */
	573	sprintf (lslr_annex, "%d/lslr", fd);
	574	memset (buf, 0, sizeof buf);
	575	if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
	576	0, sizeof buf) <= 0)
	577	return ret;
	578
	579	lslr = strtoul (buf, NULL, 16);
	580	ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
	581
a13e2c95 UW	582	return ret == len ? 0 : EIO;
	583	}
	584
	585	/* Copy LEN bytes of data from debugger memory at MYADDR
	586	to inferior's memory at MEMADDR.
	587	On failure (cannot write the inferior)
	588	returns the value of errno. */
	589	static int
	590	spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
	591	{
	592	int fd, ret;
	593	CORE_ADDR addr;
d2ed6730 UW	594	char annex[32], lslr_annex[32], buf[32];
d2ed6730 UW	595	CORE_ADDR lslr;
a13e2c95 UW	596
	597	/* We must be stopped on a spu_run system call. */
	598	if (!parse_spufs_run (&fd, &addr))
	599	return 0;
	600
	601	/* Use the "mem" spufs file to access SPU local store. */
	602	sprintf (annex, "%d/mem", fd);
	603	ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
d2ed6730 UW	604	if (ret > 0)
	605	return ret == len ? 0 : EIO;
	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	sprintf (lslr_annex, "%d/lslr", fd);
	612	memset (buf, 0, sizeof buf);
	613	if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
	614	0, sizeof buf) <= 0)
	615	return ret;
	616
	617	lslr = strtoul (buf, NULL, 16);
	618	ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
	619
a13e2c95 UW	620	return ret == len ? 0 : EIO;
	621	}
	622
	623	/* Look up special symbols -- unneded here. */
	624	static void
	625	spu_look_up_symbols (void)
	626	{
	627	}
	628
	629	/* Send signal to inferior. */
	630	static void
ef57601b	631	spu_request_interrupt (void)
a13e2c95	632	{
5472f405	633	syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);
a13e2c95 UW	634	}
a13e2c95 UW	635
a13e2c95 UW	636	static struct target_ops spu_target_ops = {
	637	spu_create_inferior,
	638	spu_attach,
	639	spu_kill,
	640	spu_detach,
505106cd	641	spu_mourn,
444d6139	642	spu_join,
a13e2c95 UW	643	spu_thread_alive,
	644	spu_resume,
	645	spu_wait,
	646	spu_fetch_registers,
	647	spu_store_registers,
90d74c30	648	NULL, /* prepare_to_access_memory */
0146f85b	649	NULL, /* done_accessing_memory */
a13e2c95 UW	650	spu_read_memory,
	651	spu_write_memory,
	652	spu_look_up_symbols,
ef57601b	653	spu_request_interrupt,
a13e2c95	654	NULL,
ab39bf24 UW	655	NULL,
	656	NULL,
	657	NULL,
	658	NULL,
	659	NULL,
	660	NULL,
0e7f50da	661	spu_proc_xfer_spu,
59a016f0	662	hostio_last_error_from_errno,
a13e2c95 UW	663	};
	664
	665	void
	666	initialize_low (void)
	667	{
	668	static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
	669
	670	set_target_ops (&spu_target_ops);
	671	set_breakpoint_data (breakpoint, sizeof breakpoint);
d05b4ac3	672	init_registers_spu ();
a13e2c95	673	}