1 /* Low level interface to SPUs, for the remote server for GDB.
2 Copyright (C) 2006-2015 Free Software Foundation, Inc.
4 Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
6 This file is part of GDB.
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
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include <sys/ptrace.h>
27 #include <sys/syscall.h>
28 #include "filestuff.h"
31 /* Some older glibc versions do not define this. */
33 #define __WNOTHREAD 0x20000000 /* Don't wait on children of other
34 threads in this group */
37 #define PTRACE_TYPE_RET long
38 #define PTRACE_TYPE_ARG3 long
40 /* Number of registers. */
41 #define SPU_NUM_REGS 130
42 #define SPU_NUM_CORE_REGS 128
44 /* Special registers. */
45 #define SPU_ID_REGNUM 128
46 #define SPU_PC_REGNUM 129
48 /* PPU side system calls. */
49 #define INSTR_SC 0x44000002
50 #define NR_spu_run 0x0116
52 /* These are used in remote-utils.c. */
53 int using_threads = 0;
55 /* Defined in auto-generated file reg-spu.c. */
56 void init_registers_spu (void);
57 extern const struct target_desc *tdesc_spu;
59 /* Fetch PPU register REGNO. */
61 fetch_ppc_register (int regno)
65 int tid = ptid_get_lwp (current_ptid);
68 /* If running as a 32-bit process on a 64-bit system, we attempt
69 to get the full 64-bit register content of the target process.
70 If the PPC special ptrace call fails, we're on a 32-bit system;
71 just fall through to the regular ptrace call in that case. */
76 ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
77 (PTRACE_TYPE_ARG3) (regno * 8), buf);
79 ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
80 (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
82 return (CORE_ADDR) *(unsigned long long *)buf;
87 res = ptrace (PT_READ_U, tid,
88 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
92 sprintf (mess, "reading PPC register #%d", regno);
93 perror_with_name (mess);
96 return (CORE_ADDR) (unsigned long) res;
99 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
101 fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
105 #ifndef __powerpc64__
108 unsigned long long addr_8 = (unsigned long long) memaddr;
109 ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
113 *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
118 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
120 store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
124 #ifndef __powerpc64__
127 unsigned long long addr_8 = (unsigned long long) memaddr;
128 ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
132 ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
137 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
139 fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
143 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
144 int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
145 / sizeof (PTRACE_TYPE_RET));
146 PTRACE_TYPE_RET *buffer;
148 int tid = ptid_get_lwp (current_ptid);
150 buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
151 for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
152 if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
156 (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
162 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
164 store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
168 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
169 int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
170 / sizeof (PTRACE_TYPE_RET));
171 PTRACE_TYPE_RET *buffer;
173 int tid = ptid_get_lwp (current_ptid);
175 buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
177 if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
178 if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
182 if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
183 * sizeof (PTRACE_TYPE_RET),
184 &buffer[count - 1])) != 0)
187 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
190 for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
191 if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
198 /* If the PPU thread is currently stopped on a spu_run system call,
199 return to FD and ADDR the file handle and NPC parameter address
200 used with the system call. Return non-zero if successful. */
202 parse_spufs_run (int *fd, CORE_ADDR *addr)
205 CORE_ADDR pc = fetch_ppc_register (32); /* nip */
207 /* Fetch instruction preceding current NIP. */
208 if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
210 /* It should be a "sc" instruction. */
211 if (insn != INSTR_SC)
213 /* System call number should be NR_spu_run. */
214 if (fetch_ppc_register (0) != NR_spu_run)
217 /* Register 3 contains fd, register 4 the NPC param pointer. */
218 *fd = fetch_ppc_register (34); /* orig_gpr3 */
219 *addr = fetch_ppc_register (4);
224 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
225 using the /proc file system. */
227 spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
228 const unsigned char *writebuf,
229 CORE_ADDR offset, int len)
238 sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
239 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
244 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
251 ret = write (fd, writebuf, (size_t) len);
253 ret = read (fd, readbuf, (size_t) len);
260 /* Start an inferior process and returns its pid.
261 ALLARGS is a vector of program-name and args. */
263 spu_create_inferior (char *program, char **allargs)
267 struct process_info *proc;
271 perror_with_name ("fork");
276 ptrace (PTRACE_TRACEME, 0, 0, 0);
280 execv (program, allargs);
282 execvp (program, allargs);
284 fprintf (stderr, "Cannot exec %s: %s.\n", program,
290 proc = add_process (pid, 0);
291 proc->tdesc = tdesc_spu;
293 ptid = ptid_build (pid, pid, 0);
294 add_thread (ptid, NULL);
298 /* Attach to an inferior process. */
300 spu_attach (unsigned long pid)
303 struct process_info *proc;
305 if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
307 fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
308 strerror (errno), errno);
313 proc = add_process (pid, 1);
314 proc->tdesc = tdesc_spu;
315 ptid = ptid_build (pid, pid, 0);
316 add_thread (ptid, NULL);
320 /* Kill the inferior process. */
325 struct process_info *process = find_process_pid (pid);
329 ptrace (PTRACE_KILL, pid, 0, 0);
332 ret = waitpid (pid, &status, 0);
333 if (WIFEXITED (status) || WIFSIGNALED (status))
335 } while (ret != -1 || errno != ECHILD);
338 remove_process (process);
342 /* Detach from inferior process. */
346 struct process_info *process = find_process_pid (pid);
350 ptrace (PTRACE_DETACH, pid, 0, 0);
353 remove_process (process);
358 spu_mourn (struct process_info *process)
360 remove_process (process);
369 ret = waitpid (pid, &status, 0);
370 if (WIFEXITED (status) || WIFSIGNALED (status))
372 } while (ret != -1 || errno != ECHILD);
375 /* Return nonzero if the given thread is still alive. */
377 spu_thread_alive (ptid_t ptid)
379 return ptid_equal (ptid, current_ptid);
382 /* Resume process. */
384 spu_resume (struct thread_resume *resume_info, size_t n)
388 for (i = 0; i < n; i++)
389 if (ptid_equal (resume_info[i].thread, minus_one_ptid)
390 || ptid_equal (resume_info[i].thread, current_ptid))
396 /* We don't support hardware single-stepping right now, assume
397 GDB knows to use software single-stepping. */
398 if (resume_info[i].kind == resume_step)
399 fprintf (stderr, "Hardware single-step not supported.\n");
401 regcache_invalidate ();
404 ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig);
406 perror_with_name ("ptrace");
409 /* Wait for process, returns status. */
411 spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
413 int pid = ptid_get_pid (ptid);
419 ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);
424 perror_with_name ("waitpid");
432 /* On the first wait, continue running the inferior until we are
433 blocked inside an spu_run system call. */
439 while (!parse_spufs_run (&fd, &addr))
441 ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
442 waitpid (pid, NULL, __WALL | __WNOTHREAD);
448 fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
449 ourstatus->kind = TARGET_WAITKIND_EXITED;
450 ourstatus->value.integer = WEXITSTATUS (w);
452 return pid_to_ptid (ret);
454 else if (!WIFSTOPPED (w))
456 fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
457 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
458 ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
460 return pid_to_ptid (ret);
463 /* After attach, we may have received a SIGSTOP. Do not return this
464 as signal to GDB, or else it will try to continue with SIGSTOP ... */
467 ourstatus->kind = TARGET_WAITKIND_STOPPED;
468 ourstatus->value.sig = GDB_SIGNAL_0;
469 return ptid_build (ret, ret, 0);
472 ourstatus->kind = TARGET_WAITKIND_STOPPED;
473 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
474 return ptid_build (ret, ret, 0);
477 /* Fetch inferior registers. */
479 spu_fetch_registers (struct regcache *regcache, int regno)
484 /* We must be stopped on a spu_run system call. */
485 if (!parse_spufs_run (&fd, &addr))
488 /* The ID register holds the spufs file handle. */
489 if (regno == -1 || regno == SPU_ID_REGNUM)
490 supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
492 /* The NPC register is found at ADDR. */
493 if (regno == -1 || regno == SPU_PC_REGNUM)
496 if (fetch_ppc_memory (addr, buf, 4) == 0)
497 supply_register (regcache, SPU_PC_REGNUM, buf);
500 /* The GPRs are found in the "regs" spufs file. */
501 if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
503 unsigned char buf[16*SPU_NUM_CORE_REGS];
507 sprintf (annex, "%d/regs", fd);
508 if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
509 for (i = 0; i < SPU_NUM_CORE_REGS; i++)
510 supply_register (regcache, i, buf + i*16);
514 /* Store inferior registers. */
516 spu_store_registers (struct regcache *regcache, int regno)
521 /* ??? Some callers use 0 to mean all registers. */
525 /* We must be stopped on a spu_run system call. */
526 if (!parse_spufs_run (&fd, &addr))
529 /* The NPC register is found at ADDR. */
530 if (regno == -1 || regno == SPU_PC_REGNUM)
533 collect_register (regcache, SPU_PC_REGNUM, buf);
534 store_ppc_memory (addr, buf, 4);
537 /* The GPRs are found in the "regs" spufs file. */
538 if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
540 unsigned char buf[16*SPU_NUM_CORE_REGS];
544 for (i = 0; i < SPU_NUM_CORE_REGS; i++)
545 collect_register (regcache, i, buf + i*16);
547 sprintf (annex, "%d/regs", fd);
548 spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
552 /* Copy LEN bytes from inferior's memory starting at MEMADDR
553 to debugger memory starting at MYADDR. */
555 spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
559 char annex[32], lslr_annex[32], buf[32];
562 /* We must be stopped on a spu_run system call. */
563 if (!parse_spufs_run (&fd, &addr))
566 /* Use the "mem" spufs file to access SPU local store. */
567 sprintf (annex, "%d/mem", fd);
568 ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
570 return ret == len ? 0 : EIO;
572 /* SPU local store access wraps the address around at the
573 local store limit. We emulate this here. To avoid needing
574 an extra access to retrieve the LSLR, we only do that after
575 trying the original address first, and getting end-of-file. */
576 sprintf (lslr_annex, "%d/lslr", fd);
577 memset (buf, 0, sizeof buf);
578 if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
582 lslr = strtoul (buf, NULL, 16);
583 ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
585 return ret == len ? 0 : EIO;
588 /* Copy LEN bytes of data from debugger memory at MYADDR
589 to inferior's memory at MEMADDR.
590 On failure (cannot write the inferior)
591 returns the value of errno. */
593 spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
597 char annex[32], lslr_annex[32], buf[32];
600 /* We must be stopped on a spu_run system call. */
601 if (!parse_spufs_run (&fd, &addr))
604 /* Use the "mem" spufs file to access SPU local store. */
605 sprintf (annex, "%d/mem", fd);
606 ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
608 return ret == len ? 0 : EIO;
610 /* SPU local store access wraps the address around at the
611 local store limit. We emulate this here. To avoid needing
612 an extra access to retrieve the LSLR, we only do that after
613 trying the original address first, and getting end-of-file. */
614 sprintf (lslr_annex, "%d/lslr", fd);
615 memset (buf, 0, sizeof buf);
616 if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
620 lslr = strtoul (buf, NULL, 16);
621 ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
623 return ret == len ? 0 : EIO;
626 /* Look up special symbols -- unneded here. */
628 spu_look_up_symbols (void)
632 /* Send signal to inferior. */
634 spu_request_interrupt (void)
636 syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);
639 static struct target_ops spu_target_ops = {
651 NULL, /* prepare_to_access_memory */
652 NULL, /* done_accessing_memory */
656 spu_request_interrupt,
658 NULL, /* supports_z_point_type */
666 hostio_last_error_from_errno,
670 initialize_low (void)
672 static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
674 set_target_ops (&spu_target_ops);
675 set_breakpoint_data (breakpoint, sizeof breakpoint);
676 init_registers_spu ();