/* SPU native-dependent code for GDB, the GNU debugger.
- Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2006-2012 Free Software Foundation, Inc.
Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
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 2 of the License, or
+ 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,
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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ 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 <sys/ptrace.h>
#include <asm/ptrace.h>
ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
(PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
if (errno == 0)
- return (ULONGEST) *(unsigned long long *)buf;
+ return (ULONGEST) *(uint64_t *)buf;
}
#endif
#ifndef __powerpc64__
if (memaddr >> 32)
{
- unsigned long long addr_8 = (unsigned long long) memaddr;
+ uint64_t addr_8 = (uint64_t) memaddr;
ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
}
else
#ifndef __powerpc64__
if (memaddr >> 32)
{
- unsigned long long addr_8 = (unsigned long long) memaddr;
+ uint64_t addr_8 = (uint64_t) memaddr;
ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
}
else
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;
+ {
+ ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
+ if (ret)
+ return ret;
+ }
memcpy (myaddr,
(char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
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;
+ {
+ ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
+ if (ret)
+ return ret;
+ }
if (count > 1)
- if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
+ {
+ ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
* sizeof (PTRACE_TYPE_RET),
- &buffer[count - 1])) != 0)
- return 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))
- if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
- return ret;
+ {
+ ret = store_ppc_memory_1 (tid, addr, buffer[i]);
+ if (ret)
+ return ret;
+ }
return 0;
}
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 */
if (fetch_ppc_memory (pc-4, buf, 4) != 0)
return 0;
/* It should be a "sc" instruction. */
- if (extract_unsigned_integer (buf, 4) != INSTR_SC)
+ 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)
&& lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
{
close (fd);
- return -1;
+ return 0;
}
if (writebuf)
spu_bfd_open (ULONGEST addr)
{
struct bfd *nbfd;
+ asection *spu_name;
ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
*open_closure = addr;
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;
}
if (len <= 0 || len >= sizeof id)
return;
id[len] = 0;
- if (sscanf (id, "0x%llx", &addr) != 1)
+ addr = strtoulst (id, NULL, 16);
+ if (!addr)
return;
/* Open BFD representing SPE executable and read its symbols. */
nbfd = spu_bfd_open (addr);
if (nbfd)
- symbol_file_add_from_bfd (nbfd, 0, NULL, 1, 0);
+ symbol_file_add_from_bfd (nbfd, SYMFILE_VERBOSE | SYMFILE_MAINLINE,
+ NULL, 0, NULL);
}
/* 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 (ptid_t ptid, struct target_waitstatus *ourstatus)
+spu_child_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus, int options)
{
int save_errno;
int status;
{
set_sigint_trap (); /* Causes SIGINT to be passed on to the
attached process. */
- set_sigio_trap ();
pid = waitpid (PIDGET (ptid), &status, 0);
if (pid == -1 && errno == ECHILD)
save_errno = EINTR;
}
- clear_sigio_trap ();
clear_sigint_trap ();
}
while (pid == -1 && save_errno == EINTR);
if (pid == -1)
{
- warning ("Child process unexpectedly missing: %s",
+ warning (_("Child process unexpectedly missing: %s"),
safe_strerror (save_errno));
/* Claim it exited with unknown signal. */
ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
- ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
- return minus_one_ptid;
+ ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
+ return inferior_ptid;
}
store_waitstatus (ourstatus, status);
/* Override the fetch_inferior_register routine. */
static void
-spu_fetch_inferior_registers (struct regcache *regcache, int regno)
+spu_fetch_inferior_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
int fd;
ULONGEST addr;
/* 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);
char buf[4];
- store_unsigned_integer (buf, 4, fd);
+ store_unsigned_integer (buf, 4, byte_order, fd);
regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
}
/* Override the store_inferior_register routine. */
static void
-spu_store_inferior_registers (struct regcache *regcache, int regno)
+spu_store_inferior_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
int fd;
ULONGEST addr;
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];
+ 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))
/* Use the "mem" spufs file to access SPU local store. */
xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
- return spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len);
+ 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;
/* Register SPU target. */
add_target (t);
}
-