[deliverable/binutils-gdb.git] / gdb / spu-multiarch.c

/* Cell SPU GNU/Linux multi-architecture debugging support.
   Copyright (C) 2009-2015 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 "gdbcmd.h"
#include "arch-utils.h"
#include "observer.h"
#include "inferior.h"
#include "regcache.h"
#include "symfile.h"
#include "objfiles.h"
#include "solib.h"
#include "solist.h"

#include "ppc-tdep.h"
#include "ppc-linux-tdep.h"
#include "spu-tdep.h"

/* This module's target vector.  */
static struct target_ops spu_ops;

/* Number of SPE objects loaded into the current inferior.  */
static int spu_nr_solib;

/* Stand-alone SPE executable?  */
#define spu_standalone_p() \
  (symfile_objfile && symfile_objfile->obfd \
   && bfd_get_arch (symfile_objfile->obfd) == bfd_arch_spu)

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

/* 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 (ptid_t ptid, int *fd, CORE_ADDR *addr)
{
  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  struct gdbarch_tdep *tdep;
  struct regcache *regcache;
  gdb_byte buf[4];
  ULONGEST regval;

  /* If we're not on PPU, there's nothing to detect.  */
  if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_powerpc)
    return 0;

  /* Get PPU-side registers.  */
  regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
  tdep = gdbarch_tdep (target_gdbarch ());

  /* Fetch instruction preceding current NIP.  */
  if (target_read_memory (regcache_read_pc (regcache) - 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.  */
  regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum, &regval);
  if (regval != NR_spu_run)
    return 0;

  /* Register 3 contains fd, register 4 the NPC param pointer.  */
  regcache_cooked_read_unsigned (regcache, PPC_ORIG_R3_REGNUM, &regval);
  *fd = (int) regval;
  regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 4, &regval);
  *addr = (CORE_ADDR) regval;
  return 1;
}

/* Find gdbarch for SPU context SPUFS_FD.  */
static struct gdbarch *
spu_gdbarch (int spufs_fd)
{
  struct gdbarch_info info;
  gdbarch_info_init (&info);
  info.bfd_arch_info = bfd_lookup_arch (bfd_arch_spu, bfd_mach_spu);
  info.byte_order = BFD_ENDIAN_BIG;
  info.osabi = GDB_OSABI_LINUX;
  info.tdep_info = (void *) &spufs_fd;
  return gdbarch_find_by_info (info);
}

/* Override the to_thread_architecture routine.  */
static struct gdbarch *
spu_thread_architecture (struct target_ops *ops, ptid_t ptid)
{
  int spufs_fd;
  CORE_ADDR spufs_addr;

  if (parse_spufs_run (ptid, &spufs_fd, &spufs_addr))
    return spu_gdbarch (spufs_fd);

  return target_gdbarch ();
}

/* Override the to_region_ok_for_hw_watchpoint routine.  */
static int
spu_region_ok_for_hw_watchpoint (struct target_ops *self,
				 CORE_ADDR addr, int len)
{
  struct target_ops *ops_beneath = find_target_beneath (self);

  /* We cannot watch SPU local store.  */
  if (SPUADDR_SPU (addr) != -1)
    return 0;

  return ops_beneath->to_region_ok_for_hw_watchpoint (ops_beneath, addr, len);
}

/* Override the to_fetch_registers routine.  */
static void
spu_fetch_registers (struct target_ops *ops,
		     struct regcache *regcache, int regno)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  struct target_ops *ops_beneath = find_target_beneath (ops);
  int spufs_fd;
  CORE_ADDR spufs_addr;

  /* This version applies only if we're currently in spu_run.  */
  if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
    {
      ops_beneath->to_fetch_registers (ops_beneath, regcache, regno);
      return;
    }

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

  /* The ID register holds the spufs file handle.  */
  if (regno == -1 || regno == SPU_ID_REGNUM)
    {
      gdb_byte buf[4];
      store_unsigned_integer (buf, 4, byte_order, spufs_fd);
      regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
    }

  /* The NPC register is found in PPC memory at SPUFS_ADDR.  */
  if (regno == -1 || regno == SPU_PC_REGNUM)
    {
      gdb_byte buf[4];

      if (target_read (ops_beneath, TARGET_OBJECT_MEMORY, NULL,
		       buf, spufs_addr, sizeof buf) == sizeof buf)
	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", spufs_fd);
      if (target_read (ops_beneath, TARGET_OBJECT_SPU, annex,
		       buf, 0, sizeof buf) == sizeof buf)
	for (i = 0; i < SPU_NUM_GPRS; i++)
	  regcache_raw_supply (regcache, i, buf + i*16);
    }
}

/* Override the to_store_registers routine.  */
static void
spu_store_registers (struct target_ops *ops,
		     struct regcache *regcache, int regno)
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  struct target_ops *ops_beneath = find_target_beneath (ops);
  int spufs_fd;
  CORE_ADDR spufs_addr;

  /* This version applies only if we're currently in spu_run.  */
  if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
    {
      ops_beneath->to_store_registers (ops_beneath, regcache, regno);
      return;
    }

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

  /* The NPC register is found in PPC memory at SPUFS_ADDR.  */
  if (regno == -1 || regno == SPU_PC_REGNUM)
    {
      gdb_byte buf[4];
      regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);

      target_write (ops_beneath, TARGET_OBJECT_MEMORY, NULL,
		    buf, spufs_addr, sizeof 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;

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

      xsnprintf (annex, sizeof annex, "%d/regs", spufs_fd);
      target_write (ops_beneath, TARGET_OBJECT_SPU, annex,
		    buf, 0, sizeof buf);
    }
}

/* 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)
{
  struct target_ops *ops_beneath = find_target_beneath (ops);

  /* Use the "mem" spufs file to access SPU local store.  */
  if (object == TARGET_OBJECT_MEMORY)
    {
      int fd = SPUADDR_SPU (offset);
      CORE_ADDR addr = SPUADDR_ADDR (offset);
      char mem_annex[32], lslr_annex[32];
      gdb_byte buf[32];
      ULONGEST lslr;
      enum target_xfer_status ret;

      if (fd >= 0)
	{
	  xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
	  ret = ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
					      mem_annex, readbuf, writebuf,
					      addr, 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 (ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
					    lslr_annex, buf, NULL,
					    0, sizeof buf, xfered_len)
	      != TARGET_XFER_OK)
	    return ret;

	  lslr = strtoulst ((char *) buf, NULL, 16);
	  return ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
					       mem_annex, readbuf, writebuf,
					       addr & lslr, len, xfered_len);
	}
    }

  return ops_beneath->to_xfer_partial (ops_beneath, object, annex,
				       readbuf, writebuf, offset, len, xfered_len);
}

/* Override the to_search_memory routine.  */
static int
spu_search_memory (struct target_ops* ops,
		   CORE_ADDR start_addr, ULONGEST search_space_len,
		   const gdb_byte *pattern, ULONGEST pattern_len,
		   CORE_ADDR *found_addrp)
{
  struct target_ops *ops_beneath = find_target_beneath (ops);

  /* For SPU local store, always fall back to the simple method.  */
  if (SPUADDR_SPU (start_addr) >= 0)
    return simple_search_memory (ops,
				 start_addr, search_space_len,
				 pattern, pattern_len, found_addrp);

  return ops_beneath->to_search_memory (ops_beneath,
					start_addr, search_space_len,
					pattern, pattern_len, found_addrp);
}


/* Push and pop the SPU multi-architecture support target.  */

static void
spu_multiarch_activate (void)
{
  /* If GDB was configured without SPU architecture support,
     we cannot install SPU multi-architecture support either.  */
  if (spu_gdbarch (-1) == NULL)
    return;

  push_target (&spu_ops);

  /* Make sure the thread architecture is re-evaluated.  */
  registers_changed ();
}

static void
spu_multiarch_deactivate (void)
{
  unpush_target (&spu_ops);

  /* Make sure the thread architecture is re-evaluated.  */
  registers_changed ();
}

static void
spu_multiarch_inferior_created (struct target_ops *ops, int from_tty)
{
  if (spu_standalone_p ())
    spu_multiarch_activate ();
}

static void
spu_multiarch_solib_loaded (struct so_list *so)
{
  if (!spu_standalone_p ())
    if (so->abfd && bfd_get_arch (so->abfd) == bfd_arch_spu)
      if (spu_nr_solib++ == 0)
	spu_multiarch_activate ();
}

static void
spu_multiarch_solib_unloaded (struct so_list *so)
{
  if (!spu_standalone_p ())
    if (so->abfd && bfd_get_arch (so->abfd) == bfd_arch_spu)
      if (--spu_nr_solib == 0)
	spu_multiarch_deactivate ();
}

static void
spu_mourn_inferior (struct target_ops *ops)
{
  struct target_ops *ops_beneath = find_target_beneath (ops);

  ops_beneath->to_mourn_inferior (ops_beneath);
  spu_multiarch_deactivate ();
}


/* Initialize the SPU multi-architecture support target.  */

static void
init_spu_ops (void)
{
  spu_ops.to_shortname = "spu";
  spu_ops.to_longname = "SPU multi-architecture support.";
  spu_ops.to_doc = "SPU multi-architecture support.";
  spu_ops.to_mourn_inferior = spu_mourn_inferior;
  spu_ops.to_fetch_registers = spu_fetch_registers;
  spu_ops.to_store_registers = spu_store_registers;
  spu_ops.to_xfer_partial = spu_xfer_partial;
  spu_ops.to_search_memory = spu_search_memory;
  spu_ops.to_region_ok_for_hw_watchpoint = spu_region_ok_for_hw_watchpoint;
  spu_ops.to_thread_architecture = spu_thread_architecture;
  spu_ops.to_stratum = arch_stratum;
  spu_ops.to_magic = OPS_MAGIC;
}

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

void
_initialize_spu_multiarch (void)
{
  /* Install ourselves on the target stack.  */
  init_spu_ops ();
  complete_target_initialization (&spu_ops);

  /* Install observers to watch for SPU objects.  */
  observer_attach_inferior_created (spu_multiarch_inferior_created);
  observer_attach_solib_loaded (spu_multiarch_solib_loaded);
  observer_attach_solib_unloaded (spu_multiarch_solib_unloaded);
}
Commit	Line	Data
85e747d2	1	/* Cell SPU GNU/Linux multi-architecture debugging support.
32d0add0	2	Copyright (C) 2009-2015 Free Software Foundation, Inc.
85e747d2 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
dcf7800b	10	the Free Software Foundation; either version 3 of the License, or
85e747d2 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
dcf7800b	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
85e747d2 UW	20
	21	#include "defs.h"
	22	#include "gdbcore.h"
	23	#include "gdbcmd.h"
85e747d2 UW	24	#include "arch-utils.h"
	25	#include "observer.h"
	26	#include "inferior.h"
	27	#include "regcache.h"
	28	#include "symfile.h"
	29	#include "objfiles.h"
	30	#include "solib.h"
	31	#include "solist.h"
	32
	33	#include "ppc-tdep.h"
	34	#include "ppc-linux-tdep.h"
	35	#include "spu-tdep.h"
	36
	37	/* This module's target vector. */
	38	static struct target_ops spu_ops;
	39
	40	/* Number of SPE objects loaded into the current inferior. */
	41	static int spu_nr_solib;
	42
	43	/* Stand-alone SPE executable? */
	44	#define spu_standalone_p() \
	45	(symfile_objfile && symfile_objfile->obfd \
	46	&& bfd_get_arch (symfile_objfile->obfd) == bfd_arch_spu)
	47
	48	/* PPU side system calls. */
	49	#define INSTR_SC 0x44000002
	50	#define NR_spu_run 0x0116
	51
	52	/* If the PPU thread is currently stopped on a spu_run system call,
	53	return to FD and ADDR the file handle and NPC parameter address
	54	used with the system call. Return non-zero if successful. */
	55	static int
	56	parse_spufs_run (ptid_t ptid, int fd, CORE_ADDR addr)
	57	{
f5656ead	58	enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
85e747d2 UW	59	struct gdbarch_tdep *tdep;
85e747d2 UW	60	struct regcache *regcache;
e362b510	61	gdb_byte buf[4];
85e747d2 UW	62	ULONGEST regval;
	63
	64	/* If we're not on PPU, there's nothing to detect. */
f5656ead	65	if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_powerpc)
85e747d2 UW	66	return 0;
	67
	68	/* Get PPU-side registers. */
f5656ead TT	69	regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
f5656ead TT	70	tdep = gdbarch_tdep (target_gdbarch ());
85e747d2 UW	71
	72	/* Fetch instruction preceding current NIP. */
	73	if (target_read_memory (regcache_read_pc (regcache) - 4, buf, 4) != 0)
	74	return 0;
	75	/* It should be a "sc" instruction. */
	76	if (extract_unsigned_integer (buf, 4, byte_order) != INSTR_SC)
	77	return 0;
	78	/* System call number should be NR_spu_run. */
	79	regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum, &regval);
	80	if (regval != NR_spu_run)
	81	return 0;
	82
	83	/* Register 3 contains fd, register 4 the NPC param pointer. */
	84	regcache_cooked_read_unsigned (regcache, PPC_ORIG_R3_REGNUM, &regval);
	85	*fd = (int) regval;
	86	regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 4, &regval);
	87	*addr = (CORE_ADDR) regval;
	88	return 1;
	89	}
	90
	91	/* Find gdbarch for SPU context SPUFS_FD. */
	92	static struct gdbarch *
	93	spu_gdbarch (int spufs_fd)
	94	{
	95	struct gdbarch_info info;
	96	gdbarch_info_init (&info);
	97	info.bfd_arch_info = bfd_lookup_arch (bfd_arch_spu, bfd_mach_spu);
	98	info.byte_order = BFD_ENDIAN_BIG;
	99	info.osabi = GDB_OSABI_LINUX;
	100	info.tdep_info = (void *) &spufs_fd;
	101	return gdbarch_find_by_info (info);
	102	}
	103
	104	/* Override the to_thread_architecture routine. */
	105	static struct gdbarch *
	106	spu_thread_architecture (struct target_ops *ops, ptid_t ptid)
	107	{
	108	int spufs_fd;
	109	CORE_ADDR spufs_addr;
	110
	111	if (parse_spufs_run (ptid, &spufs_fd, &spufs_addr))
	112	return spu_gdbarch (spufs_fd);
	113
f5656ead	114	return target_gdbarch ();
85e747d2 UW	115	}
	116
	117	/* Override the to_region_ok_for_hw_watchpoint routine. */
	118	static int
31568a15 TT	119	spu_region_ok_for_hw_watchpoint (struct target_ops *self,
31568a15 TT	120	CORE_ADDR addr, int len)
85e747d2	121	{
44e89118	122	struct target_ops *ops_beneath = find_target_beneath (self);
85e747d2 UW	123
	124	/* We cannot watch SPU local store. */
	125	if (SPUADDR_SPU (addr) != -1)
	126	return 0;
	127
e75fdfca	128	return ops_beneath->to_region_ok_for_hw_watchpoint (ops_beneath, addr, len);
85e747d2 UW	129	}
	130
	131	/* Override the to_fetch_registers routine. */
	132	static void
	133	spu_fetch_registers (struct target_ops *ops,
	134	struct regcache *regcache, int regno)
	135	{
	136	struct gdbarch *gdbarch = get_regcache_arch (regcache);
	137	enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
	138	struct target_ops *ops_beneath = find_target_beneath (ops);
	139	int spufs_fd;
	140	CORE_ADDR spufs_addr;
	141
	142	/* This version applies only if we're currently in spu_run. */
	143	if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
	144	{
85e747d2 UW	145	ops_beneath->to_fetch_registers (ops_beneath, regcache, regno);
	146	return;
	147	}
	148
	149	/* We must be stopped on a spu_run system call. */
	150	if (!parse_spufs_run (inferior_ptid, &spufs_fd, &spufs_addr))
	151	return;
	152
	153	/* The ID register holds the spufs file handle. */
	154	if (regno == -1 \|\| regno == SPU_ID_REGNUM)
	155	{
e362b510	156	gdb_byte buf[4];
85e747d2 UW	157	store_unsigned_integer (buf, 4, byte_order, spufs_fd);
	158	regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
	159	}
	160
	161	/* The NPC register is found in PPC memory at SPUFS_ADDR. */
	162	if (regno == -1 \|\| regno == SPU_PC_REGNUM)
	163	{
e362b510	164	gdb_byte buf[4];
85e747d2 UW	165
	166	if (target_read (ops_beneath, TARGET_OBJECT_MEMORY, NULL,
	167	buf, spufs_addr, sizeof buf) == sizeof buf)
	168	regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
	169	}
	170
	171	/* The GPRs are found in the "regs" spufs file. */
	172	if (regno == -1 \|\| (regno >= 0 && regno < SPU_NUM_GPRS))
	173	{
e362b510 PA	174	gdb_byte buf[16 * SPU_NUM_GPRS];
e362b510 PA	175	char annex[32];
85e747d2 UW	176	int i;
	177
	178	xsnprintf (annex, sizeof annex, "%d/regs", spufs_fd);
	179	if (target_read (ops_beneath, TARGET_OBJECT_SPU, annex,
	180	buf, 0, sizeof buf) == sizeof buf)
	181	for (i = 0; i < SPU_NUM_GPRS; i++)
	182	regcache_raw_supply (regcache, i, buf + i*16);
	183	}
	184	}
	185
	186	/* Override the to_store_registers routine. */
	187	static void
	188	spu_store_registers (struct target_ops *ops,
	189	struct regcache *regcache, int regno)
	190	{
	191	struct gdbarch *gdbarch = get_regcache_arch (regcache);
	192	struct target_ops *ops_beneath = find_target_beneath (ops);
	193	int spufs_fd;
	194	CORE_ADDR spufs_addr;
	195
	196	/* This version applies only if we're currently in spu_run. */
	197	if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
	198	{
85e747d2 UW	199	ops_beneath->to_store_registers (ops_beneath, regcache, regno);
	200	return;
	201	}
	202
	203	/* We must be stopped on a spu_run system call. */
	204	if (!parse_spufs_run (inferior_ptid, &spufs_fd, &spufs_addr))
	205	return;
	206
	207	/* The NPC register is found in PPC memory at SPUFS_ADDR. */
	208	if (regno == -1 \|\| regno == SPU_PC_REGNUM)
	209	{
e362b510	210	gdb_byte buf[4];
85e747d2 UW	211	regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
	212
	213	target_write (ops_beneath, TARGET_OBJECT_MEMORY, NULL,
	214	buf, spufs_addr, sizeof buf);
	215	}
	216
	217	/* The GPRs are found in the "regs" spufs file. */
	218	if (regno == -1 \|\| (regno >= 0 && regno < SPU_NUM_GPRS))
	219	{
e362b510 PA	220	gdb_byte buf[16 * SPU_NUM_GPRS];
e362b510 PA	221	char annex[32];
85e747d2 UW	222	int i;
	223
	224	for (i = 0; i < SPU_NUM_GPRS; i++)
	225	regcache_raw_collect (regcache, i, buf + i*16);
	226
	227	xsnprintf (annex, sizeof annex, "%d/regs", spufs_fd);
	228	target_write (ops_beneath, TARGET_OBJECT_SPU, annex,
	229	buf, 0, sizeof buf);
	230	}
	231	}
	232
	233	/* Override the to_xfer_partial routine. */
9b409511	234	static enum target_xfer_status
85e747d2 UW	235	spu_xfer_partial (struct target_ops *ops, enum target_object object,
85e747d2 UW	236	const char annex, gdb_byte readbuf,
9b409511 YQ	237	const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
9b409511 YQ	238	ULONGEST *xfered_len)
85e747d2 UW	239	{
85e747d2 UW	240	struct target_ops *ops_beneath = find_target_beneath (ops);
85e747d2 UW	241
	242	/* Use the "mem" spufs file to access SPU local store. */
	243	if (object == TARGET_OBJECT_MEMORY)
	244	{
	245	int fd = SPUADDR_SPU (offset);
	246	CORE_ADDR addr = SPUADDR_ADDR (offset);
d2ed6730 UW	247	char mem_annex[32], lslr_annex[32];
	248	gdb_byte buf[32];
	249	ULONGEST lslr;
9b409511	250	enum target_xfer_status ret;
85e747d2	251
d2ed6730	252	if (fd >= 0)
85e747d2 UW	253	{
85e747d2 UW	254	xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
d2ed6730 UW	255	ret = ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
d2ed6730 UW	256	mem_annex, readbuf, writebuf,
9b409511 YQ	257	addr, len, xfered_len);
9b409511 YQ	258	if (ret == TARGET_XFER_OK)
d2ed6730 UW	259	return ret;
	260
	261	/* SPU local store access wraps the address around at the
	262	local store limit. We emulate this here. To avoid needing
	263	an extra access to retrieve the LSLR, we only do that after
	264	trying the original address first, and getting end-of-file. */
	265	xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
	266	memset (buf, 0, sizeof buf);
	267	if (ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
	268	lslr_annex, buf, NULL,
9b409511 YQ	269	0, sizeof buf, xfered_len)
9b409511 YQ	270	!= TARGET_XFER_OK)
d2ed6730 UW	271	return ret;
d2ed6730 UW	272
001f13d8	273	lslr = strtoulst ((char *) buf, NULL, 16);
85e747d2 UW	274	return ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
85e747d2 UW	275	mem_annex, readbuf, writebuf,
9b409511	276	addr & lslr, len, xfered_len);
85e747d2 UW	277	}
	278	}
	279
	280	return ops_beneath->to_xfer_partial (ops_beneath, object, annex,
9b409511	281	readbuf, writebuf, offset, len, xfered_len);
85e747d2 UW	282	}
	283
	284	/* Override the to_search_memory routine. */
	285	static int
	286	spu_search_memory (struct target_ops* ops,
	287	CORE_ADDR start_addr, ULONGEST search_space_len,
	288	const gdb_byte *pattern, ULONGEST pattern_len,
	289	CORE_ADDR *found_addrp)
	290	{
	291	struct target_ops *ops_beneath = find_target_beneath (ops);
85e747d2	292
e75fdfca TT	293	/* For SPU local store, always fall back to the simple method. */
e75fdfca TT	294	if (SPUADDR_SPU (start_addr) >= 0)
85e747d2 UW	295	return simple_search_memory (ops,
	296	start_addr, search_space_len,
	297	pattern, pattern_len, found_addrp);
	298
	299	return ops_beneath->to_search_memory (ops_beneath,
	300	start_addr, search_space_len,
	301	pattern, pattern_len, found_addrp);
	302	}
	303
	304
	305	/* Push and pop the SPU multi-architecture support target. */
	306
	307	static void
	308	spu_multiarch_activate (void)
	309	{
	310	/* If GDB was configured without SPU architecture support,
	311	we cannot install SPU multi-architecture support either. */
	312	if (spu_gdbarch (-1) == NULL)
	313	return;
	314
	315	push_target (&spu_ops);
	316
	317	/* Make sure the thread architecture is re-evaluated. */
	318	registers_changed ();
	319	}
	320
	321	static void
	322	spu_multiarch_deactivate (void)
	323	{
	324	unpush_target (&spu_ops);
	325
	326	/* Make sure the thread architecture is re-evaluated. */
	327	registers_changed ();
	328	}
	329
	330	static void
	331	spu_multiarch_inferior_created (struct target_ops *ops, int from_tty)
	332	{
	333	if (spu_standalone_p ())
	334	spu_multiarch_activate ();
	335	}
	336
	337	static void
	338	spu_multiarch_solib_loaded (struct so_list *so)
	339	{
	340	if (!spu_standalone_p ())
	341	if (so->abfd && bfd_get_arch (so->abfd) == bfd_arch_spu)
	342	if (spu_nr_solib++ == 0)
	343	spu_multiarch_activate ();
	344	}
	345
	346	static void
	347	spu_multiarch_solib_unloaded (struct so_list *so)
	348	{
	349	if (!spu_standalone_p ())
	350	if (so->abfd && bfd_get_arch (so->abfd) == bfd_arch_spu)
	351	if (--spu_nr_solib == 0)
	352	spu_multiarch_deactivate ();
	353	}
	354
	355	static void
	356	spu_mourn_inferior (struct target_ops *ops)
	357	{
	358	struct target_ops *ops_beneath = find_target_beneath (ops);
85e747d2	359
85e747d2 UW	360	ops_beneath->to_mourn_inferior (ops_beneath);
	361	spu_multiarch_deactivate ();
	362	}
	363
	364
	365	/* Initialize the SPU multi-architecture support target. */
	366
	367	static void
	368	init_spu_ops (void)
	369	{
	370	spu_ops.to_shortname = "spu";
	371	spu_ops.to_longname = "SPU multi-architecture support.";
	372	spu_ops.to_doc = "SPU multi-architecture support.";
	373	spu_ops.to_mourn_inferior = spu_mourn_inferior;
	374	spu_ops.to_fetch_registers = spu_fetch_registers;
	375	spu_ops.to_store_registers = spu_store_registers;
	376	spu_ops.to_xfer_partial = spu_xfer_partial;
	377	spu_ops.to_search_memory = spu_search_memory;
	378	spu_ops.to_region_ok_for_hw_watchpoint = spu_region_ok_for_hw_watchpoint;
	379	spu_ops.to_thread_architecture = spu_thread_architecture;
	380	spu_ops.to_stratum = arch_stratum;
	381	spu_ops.to_magic = OPS_MAGIC;
	382	}
	383
693be288 JK	384	/* -Wmissing-prototypes */
	385	extern initialize_file_ftype _initialize_spu_multiarch;
	386
85e747d2 UW	387	void
	388	_initialize_spu_multiarch (void)
	389	{
	390	/* Install ourselves on the target stack. */
	391	init_spu_ops ();
12070676	392	complete_target_initialization (&spu_ops);
85e747d2 UW	393
	394	/* Install observers to watch for SPU objects. */
	395	observer_attach_inferior_created (spu_multiarch_inferior_created);
	396	observer_attach_solib_loaded (spu_multiarch_solib_loaded);
	397	observer_attach_solib_unloaded (spu_multiarch_solib_unloaded);
	398	}
	399