1 /* Low level interface to SPUs, for the remote server for GDB.
2 Copyright (C) 2006-2017 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"
30 #include "nat/fork-inferior.h"
32 /* Some older glibc versions do not define this. */
34 #define __WNOTHREAD 0x20000000 /* Don't wait on children of other
35 threads in this group */
38 #define PTRACE_TYPE_RET long
39 #define PTRACE_TYPE_ARG3 long
41 /* Number of registers. */
42 #define SPU_NUM_REGS 130
43 #define SPU_NUM_CORE_REGS 128
45 /* Special registers. */
46 #define SPU_ID_REGNUM 128
47 #define SPU_PC_REGNUM 129
49 /* PPU side system calls. */
50 #define INSTR_SC 0x44000002
51 #define NR_spu_run 0x0116
53 /* These are used in remote-utils.c. */
54 int using_threads = 0;
56 /* Defined in auto-generated file reg-spu.c. */
57 void init_registers_spu (void);
58 extern const struct target_desc *tdesc_spu;
60 /* Software breakpoint instruction. */
61 static const gdb_byte breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
63 /* Fetch PPU register REGNO. */
65 fetch_ppc_register (int regno)
69 int tid = ptid_get_lwp (current_ptid);
72 /* If running as a 32-bit process on a 64-bit system, we attempt
73 to get the full 64-bit register content of the target process.
74 If the PPC special ptrace call fails, we're on a 32-bit system;
75 just fall through to the regular ptrace call in that case. */
80 ptrace ((PTRACE_TYPE_ARG1) PPC_PTRACE_PEEKUSR_3264, tid,
81 (PTRACE_TYPE_ARG3) (regno * 8), buf);
83 ptrace ((PTRACE_TYPE_ARG1) PPC_PTRACE_PEEKUSR_3264, tid,
84 (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
86 return (CORE_ADDR) *(unsigned long long *)buf;
91 res = ptrace (PT_READ_U, tid,
92 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
96 sprintf (mess, "reading PPC register #%d", regno);
97 perror_with_name (mess);
100 return (CORE_ADDR) (unsigned long) res;
103 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
105 fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
109 #ifndef __powerpc64__
112 unsigned long long addr_8 = (unsigned long long) memaddr;
113 ptrace ((PTRACE_TYPE_ARG1) PPC_PTRACE_PEEKTEXT_3264, tid,
114 (PTRACE_TYPE_ARG3) &addr_8, word);
118 *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
123 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
125 store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
129 #ifndef __powerpc64__
132 unsigned long long addr_8 = (unsigned long long) memaddr;
133 ptrace ((PTRACE_TYPE_ARG1) PPC_PTRACE_POKEDATA_3264, tid,
134 (PTRACE_TYPE_ARG3) &addr_8, word);
138 ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
143 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
145 fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
149 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
150 int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
151 / sizeof (PTRACE_TYPE_RET));
152 PTRACE_TYPE_RET *buffer;
154 int tid = ptid_get_lwp (current_ptid);
156 buffer = XALLOCAVEC (PTRACE_TYPE_RET, count);
157 for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
158 if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
162 (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
168 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
170 store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
174 CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
175 int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
176 / sizeof (PTRACE_TYPE_RET));
177 PTRACE_TYPE_RET *buffer;
179 int tid = ptid_get_lwp (current_ptid);
181 buffer = XALLOCAVEC (PTRACE_TYPE_RET, count);
183 if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
184 if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
188 if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
189 * sizeof (PTRACE_TYPE_RET),
190 &buffer[count - 1])) != 0)
193 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
196 for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
197 if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
204 /* If the PPU thread is currently stopped on a spu_run system call,
205 return to FD and ADDR the file handle and NPC parameter address
206 used with the system call. Return non-zero if successful. */
208 parse_spufs_run (int *fd, CORE_ADDR *addr)
211 CORE_ADDR pc = fetch_ppc_register (32); /* nip */
213 /* Fetch instruction preceding current NIP. */
214 if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
216 /* It should be a "sc" instruction. */
217 if (insn != INSTR_SC)
219 /* System call number should be NR_spu_run. */
220 if (fetch_ppc_register (0) != NR_spu_run)
223 /* Register 3 contains fd, register 4 the NPC param pointer. */
224 *fd = fetch_ppc_register (34); /* orig_gpr3 */
225 *addr = fetch_ppc_register (4);
230 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
231 using the /proc file system. */
233 spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
234 const unsigned char *writebuf,
235 CORE_ADDR offset, int len)
244 sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
245 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
250 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
257 ret = write (fd, writebuf, (size_t) len);
259 ret = read (fd, readbuf, (size_t) len);
265 /* Callback to be used when calling fork_inferior, responsible for
266 actually initiating the tracing of the inferior. */
271 if (ptrace (PTRACE_TRACEME, 0, 0, 0) < 0)
272 trace_start_error_with_name ("ptrace");
273 if (setpgid (0, 0) < 0)
274 trace_start_error_with_name ("setpgid");
277 /* Start an inferior process and returns its pid.
278 PROGRAM is the name of the program to be started, and PROGRAM_ARGS
279 are its arguments. */
282 spu_create_inferior (const char *program,
283 const std::vector<char *> &program_argv)
287 struct process_info *proc;
288 std::string str_program_args = stringify_argv (program_args);
290 pid = fork_inferior (program,
291 str_program_args.c_str (),
292 environ_vector (get_environ ()), spu_ptrace_fun,
293 NULL, NULL, NULL, NULL);
295 post_fork_inferior (pid, program);
297 proc = add_process (pid, 0);
298 proc->tdesc = tdesc_spu;
300 ptid = ptid_build (pid, pid, 0);
301 add_thread (ptid, NULL);
305 /* Attach to an inferior process. */
307 spu_attach (unsigned long pid)
310 struct process_info *proc;
312 if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
314 fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
315 strerror (errno), errno);
320 proc = add_process (pid, 1);
321 proc->tdesc = tdesc_spu;
322 ptid = ptid_build (pid, pid, 0);
323 add_thread (ptid, NULL);
327 /* Kill the inferior process. */
332 struct process_info *process = find_process_pid (pid);
336 ptrace (PTRACE_KILL, pid, 0, 0);
339 ret = waitpid (pid, &status, 0);
340 if (WIFEXITED (status) || WIFSIGNALED (status))
342 } while (ret != -1 || errno != ECHILD);
345 remove_process (process);
349 /* Detach from inferior process. */
353 struct process_info *process = find_process_pid (pid);
357 ptrace (PTRACE_DETACH, pid, 0, 0);
360 remove_process (process);
365 spu_mourn (struct process_info *process)
367 remove_process (process);
376 ret = waitpid (pid, &status, 0);
377 if (WIFEXITED (status) || WIFSIGNALED (status))
379 } while (ret != -1 || errno != ECHILD);
382 /* Return nonzero if the given thread is still alive. */
384 spu_thread_alive (ptid_t ptid)
386 return ptid_equal (ptid, current_ptid);
389 /* Resume process. */
391 spu_resume (struct thread_resume *resume_info, size_t n)
393 struct thread_info *thr = get_first_thread ();
396 for (i = 0; i < n; i++)
397 if (ptid_equal (resume_info[i].thread, minus_one_ptid)
398 || ptid_equal (resume_info[i].thread, ptid_of (thr)))
404 /* We don't support hardware single-stepping right now, assume
405 GDB knows to use software single-stepping. */
406 if (resume_info[i].kind == resume_step)
407 fprintf (stderr, "Hardware single-step not supported.\n");
409 regcache_invalidate ();
412 ptrace (PTRACE_CONT, ptid_get_lwp (ptid_of (thr)), 0, resume_info[i].sig);
414 perror_with_name ("ptrace");
417 /* Wait for process, returns status. */
419 spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
421 int pid = ptid_get_pid (ptid);
427 ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);
432 perror_with_name ("waitpid");
440 /* On the first wait, continue running the inferior until we are
441 blocked inside an spu_run system call. */
447 while (!parse_spufs_run (&fd, &addr))
449 ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
450 waitpid (pid, NULL, __WALL | __WNOTHREAD);
456 fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
457 ourstatus->kind = TARGET_WAITKIND_EXITED;
458 ourstatus->value.integer = WEXITSTATUS (w);
460 return pid_to_ptid (ret);
462 else if (!WIFSTOPPED (w))
464 fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
465 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
466 ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
468 return pid_to_ptid (ret);
471 /* After attach, we may have received a SIGSTOP. Do not return this
472 as signal to GDB, or else it will try to continue with SIGSTOP ... */
475 ourstatus->kind = TARGET_WAITKIND_STOPPED;
476 ourstatus->value.sig = GDB_SIGNAL_0;
477 return ptid_build (ret, ret, 0);
480 ourstatus->kind = TARGET_WAITKIND_STOPPED;
481 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
482 return ptid_build (ret, ret, 0);
485 /* Fetch inferior registers. */
487 spu_fetch_registers (struct regcache *regcache, int regno)
492 /* We must be stopped on a spu_run system call. */
493 if (!parse_spufs_run (&fd, &addr))
496 /* The ID register holds the spufs file handle. */
497 if (regno == -1 || regno == SPU_ID_REGNUM)
498 supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
500 /* The NPC register is found at ADDR. */
501 if (regno == -1 || regno == SPU_PC_REGNUM)
504 if (fetch_ppc_memory (addr, buf, 4) == 0)
505 supply_register (regcache, SPU_PC_REGNUM, buf);
508 /* The GPRs are found in the "regs" spufs file. */
509 if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
511 unsigned char buf[16*SPU_NUM_CORE_REGS];
515 sprintf (annex, "%d/regs", fd);
516 if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
517 for (i = 0; i < SPU_NUM_CORE_REGS; i++)
518 supply_register (regcache, i, buf + i*16);
522 /* Store inferior registers. */
524 spu_store_registers (struct regcache *regcache, int regno)
529 /* ??? Some callers use 0 to mean all registers. */
533 /* We must be stopped on a spu_run system call. */
534 if (!parse_spufs_run (&fd, &addr))
537 /* The NPC register is found at ADDR. */
538 if (regno == -1 || regno == SPU_PC_REGNUM)
541 collect_register (regcache, SPU_PC_REGNUM, buf);
542 store_ppc_memory (addr, buf, 4);
545 /* The GPRs are found in the "regs" spufs file. */
546 if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
548 unsigned char buf[16*SPU_NUM_CORE_REGS];
552 for (i = 0; i < SPU_NUM_CORE_REGS; i++)
553 collect_register (regcache, i, buf + i*16);
555 sprintf (annex, "%d/regs", fd);
556 spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
560 /* Copy LEN bytes from inferior's memory starting at MEMADDR
561 to debugger memory starting at MYADDR. */
563 spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
567 char annex[32], lslr_annex[32], buf[32];
570 /* We must be stopped on a spu_run system call. */
571 if (!parse_spufs_run (&fd, &addr))
574 /* Use the "mem" spufs file to access SPU local store. */
575 sprintf (annex, "%d/mem", fd);
576 ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
578 return ret == len ? 0 : EIO;
580 /* SPU local store access wraps the address around at the
581 local store limit. We emulate this here. To avoid needing
582 an extra access to retrieve the LSLR, we only do that after
583 trying the original address first, and getting end-of-file. */
584 sprintf (lslr_annex, "%d/lslr", fd);
585 memset (buf, 0, sizeof buf);
586 if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
590 lslr = strtoul (buf, NULL, 16);
591 ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
593 return ret == len ? 0 : EIO;
596 /* Copy LEN bytes of data from debugger memory at MYADDR
597 to inferior's memory at MEMADDR.
598 On failure (cannot write the inferior)
599 returns the value of errno. */
601 spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
605 char annex[32], lslr_annex[32], buf[32];
608 /* We must be stopped on a spu_run system call. */
609 if (!parse_spufs_run (&fd, &addr))
612 /* Use the "mem" spufs file to access SPU local store. */
613 sprintf (annex, "%d/mem", fd);
614 ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
616 return ret == len ? 0 : EIO;
618 /* SPU local store access wraps the address around at the
619 local store limit. We emulate this here. To avoid needing
620 an extra access to retrieve the LSLR, we only do that after
621 trying the original address first, and getting end-of-file. */
622 sprintf (lslr_annex, "%d/lslr", fd);
623 memset (buf, 0, sizeof buf);
624 if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
628 lslr = strtoul (buf, NULL, 16);
629 ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
631 return ret == len ? 0 : EIO;
634 /* Look up special symbols -- unneded here. */
636 spu_look_up_symbols (void)
640 /* Send signal to inferior. */
642 spu_request_interrupt (void)
644 struct thread_info *thr = get_first_thread ();
646 syscall (SYS_tkill, lwpid_of (thr), SIGINT);
649 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
651 static const gdb_byte *
652 spu_sw_breakpoint_from_kind (int kind, int *size)
654 *size = sizeof breakpoint;
658 static struct target_ops spu_target_ops = {
660 NULL, /* post_create_inferior */
671 NULL, /* prepare_to_access_memory */
672 NULL, /* done_accessing_memory */
676 spu_request_interrupt,
678 NULL, /* supports_z_point_type */
681 NULL, /* stopped_by_sw_breakpoint */
682 NULL, /* supports_stopped_by_sw_breakpoint */
683 NULL, /* stopped_by_hw_breakpoint */
684 NULL, /* supports_stopped_by_hw_breakpoint */
685 NULL, /* supports_hardware_single_step */
691 hostio_last_error_from_errno,
692 NULL, /* qxfer_osdata */
693 NULL, /* qxfer_siginfo */
694 NULL, /* supports_non_stop */
696 NULL, /* start_non_stop */
697 NULL, /* supports_multi_process */
698 NULL, /* supports_fork_events */
699 NULL, /* supports_vfork_events */
700 NULL, /* supports_exec_events */
701 NULL, /* handle_new_gdb_connection */
702 NULL, /* handle_monitor_command */
703 NULL, /* core_of_thread */
704 NULL, /* read_loadmap */
705 NULL, /* process_qsupported */
706 NULL, /* supports_tracepoints */
709 NULL, /* thread_stopped */
710 NULL, /* get_tib_address */
711 NULL, /* pause_all */
712 NULL, /* unpause_all */
713 NULL, /* stabilize_threads */
714 NULL, /* install_fast_tracepoint_jump_pad */
716 NULL, /* supports_disable_randomization */
717 NULL, /* get_min_fast_tracepoint_insn_len */
718 NULL, /* qxfer_libraries_svr4 */
719 NULL, /* support_agent */
720 NULL, /* support_btrace */
721 NULL, /* enable_btrace */
722 NULL, /* disable_btrace */
723 NULL, /* read_btrace */
724 NULL, /* read_btrace_conf */
725 NULL, /* supports_range_stepping */
726 NULL, /* pid_to_exec_file */
727 NULL, /* multifs_open */
728 NULL, /* multifs_unlink */
729 NULL, /* multifs_readlink */
730 NULL, /* breakpoint_kind_from_pc */
731 spu_sw_breakpoint_from_kind,
735 initialize_low (void)
737 set_target_ops (&spu_target_ops);
738 init_registers_spu ();