1 /* Low level interface to SPUs, for the remote server for GDB.
2 Copyright (C) 2006-2016 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 /* Software breakpoint instruction. */
60 static const gdb_byte breakpoint
[] = { 0x00, 0x00, 0x3f, 0xff };
62 /* Fetch PPU register REGNO. */
64 fetch_ppc_register (int regno
)
68 int tid
= ptid_get_lwp (current_ptid
);
71 /* If running as a 32-bit process on a 64-bit system, we attempt
72 to get the full 64-bit register content of the target process.
73 If the PPC special ptrace call fails, we're on a 32-bit system;
74 just fall through to the regular ptrace call in that case. */
79 ptrace ((PTRACE_TYPE_ARG1
) PPC_PTRACE_PEEKUSR_3264
, tid
,
80 (PTRACE_TYPE_ARG3
) (regno
* 8), buf
);
82 ptrace ((PTRACE_TYPE_ARG1
) PPC_PTRACE_PEEKUSR_3264
, tid
,
83 (PTRACE_TYPE_ARG3
) (regno
* 8 + 4), buf
+ 4);
85 return (CORE_ADDR
) *(unsigned long long *)buf
;
90 res
= ptrace (PT_READ_U
, tid
,
91 (PTRACE_TYPE_ARG3
) (regno
* sizeof (PTRACE_TYPE_RET
)), 0);
95 sprintf (mess
, "reading PPC register #%d", regno
);
96 perror_with_name (mess
);
99 return (CORE_ADDR
) (unsigned long) res
;
102 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
104 fetch_ppc_memory_1 (int tid
, CORE_ADDR memaddr
, PTRACE_TYPE_RET
*word
)
108 #ifndef __powerpc64__
111 unsigned long long addr_8
= (unsigned long long) memaddr
;
112 ptrace ((PTRACE_TYPE_ARG1
) PPC_PTRACE_PEEKTEXT_3264
, tid
,
113 (PTRACE_TYPE_ARG3
) &addr_8
, word
);
117 *word
= ptrace (PT_READ_I
, tid
, (PTRACE_TYPE_ARG3
) (size_t) memaddr
, 0);
122 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
124 store_ppc_memory_1 (int tid
, CORE_ADDR memaddr
, PTRACE_TYPE_RET word
)
128 #ifndef __powerpc64__
131 unsigned long long addr_8
= (unsigned long long) memaddr
;
132 ptrace ((PTRACE_TYPE_ARG1
) PPC_PTRACE_POKEDATA_3264
, tid
,
133 (PTRACE_TYPE_ARG3
) &addr_8
, word
);
137 ptrace (PT_WRITE_D
, tid
, (PTRACE_TYPE_ARG3
) (size_t) memaddr
, word
);
142 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
144 fetch_ppc_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
148 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
149 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
150 / sizeof (PTRACE_TYPE_RET
));
151 PTRACE_TYPE_RET
*buffer
;
153 int tid
= ptid_get_lwp (current_ptid
);
155 buffer
= XALLOCAVEC (PTRACE_TYPE_RET
, count
);
156 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
157 if ((ret
= fetch_ppc_memory_1 (tid
, addr
, &buffer
[i
])) != 0)
161 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
167 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
169 store_ppc_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
173 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
174 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
175 / sizeof (PTRACE_TYPE_RET
));
176 PTRACE_TYPE_RET
*buffer
;
178 int tid
= ptid_get_lwp (current_ptid
);
180 buffer
= XALLOCAVEC (PTRACE_TYPE_RET
, count
);
182 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_TYPE_RET
))
183 if ((ret
= fetch_ppc_memory_1 (tid
, addr
, &buffer
[0])) != 0)
187 if ((ret
= fetch_ppc_memory_1 (tid
, addr
+ (count
- 1)
188 * sizeof (PTRACE_TYPE_RET
),
189 &buffer
[count
- 1])) != 0)
192 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
195 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
196 if ((ret
= store_ppc_memory_1 (tid
, addr
, buffer
[i
])) != 0)
203 /* If the PPU thread is currently stopped on a spu_run system call,
204 return to FD and ADDR the file handle and NPC parameter address
205 used with the system call. Return non-zero if successful. */
207 parse_spufs_run (int *fd
, CORE_ADDR
*addr
)
210 CORE_ADDR pc
= fetch_ppc_register (32); /* nip */
212 /* Fetch instruction preceding current NIP. */
213 if (fetch_ppc_memory (pc
-4, (char *) &insn
, 4) != 0)
215 /* It should be a "sc" instruction. */
216 if (insn
!= INSTR_SC
)
218 /* System call number should be NR_spu_run. */
219 if (fetch_ppc_register (0) != NR_spu_run
)
222 /* Register 3 contains fd, register 4 the NPC param pointer. */
223 *fd
= fetch_ppc_register (34); /* orig_gpr3 */
224 *addr
= fetch_ppc_register (4);
229 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
230 using the /proc file system. */
232 spu_proc_xfer_spu (const char *annex
, unsigned char *readbuf
,
233 const unsigned char *writebuf
,
234 CORE_ADDR offset
, int len
)
243 sprintf (buf
, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid
), annex
);
244 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
249 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
256 ret
= write (fd
, writebuf
, (size_t) len
);
258 ret
= read (fd
, readbuf
, (size_t) len
);
265 /* Start an inferior process and returns its pid.
266 ALLARGS is a vector of program-name and args. */
268 spu_create_inferior (char *program
, char **allargs
)
272 struct process_info
*proc
;
276 perror_with_name ("fork");
281 ptrace (PTRACE_TRACEME
, 0, 0, 0);
285 execv (program
, allargs
);
287 execvp (program
, allargs
);
289 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
295 proc
= add_process (pid
, 0);
296 proc
->tdesc
= tdesc_spu
;
298 ptid
= ptid_build (pid
, pid
, 0);
299 add_thread (ptid
, NULL
);
303 /* Attach to an inferior process. */
305 spu_attach (unsigned long pid
)
308 struct process_info
*proc
;
310 if (ptrace (PTRACE_ATTACH
, pid
, 0, 0) != 0)
312 fprintf (stderr
, "Cannot attach to process %ld: %s (%d)\n", pid
,
313 strerror (errno
), errno
);
318 proc
= add_process (pid
, 1);
319 proc
->tdesc
= tdesc_spu
;
320 ptid
= ptid_build (pid
, pid
, 0);
321 add_thread (ptid
, NULL
);
325 /* Kill the inferior process. */
330 struct process_info
*process
= find_process_pid (pid
);
334 ptrace (PTRACE_KILL
, pid
, 0, 0);
337 ret
= waitpid (pid
, &status
, 0);
338 if (WIFEXITED (status
) || WIFSIGNALED (status
))
340 } while (ret
!= -1 || errno
!= ECHILD
);
343 remove_process (process
);
347 /* Detach from inferior process. */
351 struct process_info
*process
= find_process_pid (pid
);
355 ptrace (PTRACE_DETACH
, pid
, 0, 0);
358 remove_process (process
);
363 spu_mourn (struct process_info
*process
)
365 remove_process (process
);
374 ret
= waitpid (pid
, &status
, 0);
375 if (WIFEXITED (status
) || WIFSIGNALED (status
))
377 } while (ret
!= -1 || errno
!= ECHILD
);
380 /* Return nonzero if the given thread is still alive. */
382 spu_thread_alive (ptid_t ptid
)
384 return ptid_equal (ptid
, current_ptid
);
387 /* Resume process. */
389 spu_resume (struct thread_resume
*resume_info
, size_t n
)
391 struct thread_info
*thr
= get_first_thread ();
394 for (i
= 0; i
< n
; i
++)
395 if (ptid_equal (resume_info
[i
].thread
, minus_one_ptid
)
396 || ptid_equal (resume_info
[i
].thread
, ptid_of (thr
)))
402 /* We don't support hardware single-stepping right now, assume
403 GDB knows to use software single-stepping. */
404 if (resume_info
[i
].kind
== resume_step
)
405 fprintf (stderr
, "Hardware single-step not supported.\n");
407 regcache_invalidate ();
410 ptrace (PTRACE_CONT
, ptid_get_lwp (ptid_of (thr
)), 0, resume_info
[i
].sig
);
412 perror_with_name ("ptrace");
415 /* Wait for process, returns status. */
417 spu_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
419 int pid
= ptid_get_pid (ptid
);
425 ret
= waitpid (pid
, &w
, WNOHANG
| __WALL
| __WNOTHREAD
);
430 perror_with_name ("waitpid");
438 /* On the first wait, continue running the inferior until we are
439 blocked inside an spu_run system call. */
445 while (!parse_spufs_run (&fd
, &addr
))
447 ptrace (PT_SYSCALL
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
448 waitpid (pid
, NULL
, __WALL
| __WNOTHREAD
);
454 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
455 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
456 ourstatus
->value
.integer
= WEXITSTATUS (w
);
458 return pid_to_ptid (ret
);
460 else if (!WIFSTOPPED (w
))
462 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
463 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
464 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (w
));
466 return pid_to_ptid (ret
);
469 /* After attach, we may have received a SIGSTOP. Do not return this
470 as signal to GDB, or else it will try to continue with SIGSTOP ... */
473 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
474 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
475 return ptid_build (ret
, ret
, 0);
478 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
479 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
480 return ptid_build (ret
, ret
, 0);
483 /* Fetch inferior registers. */
485 spu_fetch_registers (struct regcache
*regcache
, int regno
)
490 /* We must be stopped on a spu_run system call. */
491 if (!parse_spufs_run (&fd
, &addr
))
494 /* The ID register holds the spufs file handle. */
495 if (regno
== -1 || regno
== SPU_ID_REGNUM
)
496 supply_register (regcache
, SPU_ID_REGNUM
, (char *)&fd
);
498 /* The NPC register is found at ADDR. */
499 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
502 if (fetch_ppc_memory (addr
, buf
, 4) == 0)
503 supply_register (regcache
, SPU_PC_REGNUM
, buf
);
506 /* The GPRs are found in the "regs" spufs file. */
507 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
509 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
513 sprintf (annex
, "%d/regs", fd
);
514 if (spu_proc_xfer_spu (annex
, buf
, NULL
, 0, sizeof buf
) == sizeof buf
)
515 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
516 supply_register (regcache
, i
, buf
+ i
*16);
520 /* Store inferior registers. */
522 spu_store_registers (struct regcache
*regcache
, int regno
)
527 /* ??? Some callers use 0 to mean all registers. */
531 /* We must be stopped on a spu_run system call. */
532 if (!parse_spufs_run (&fd
, &addr
))
535 /* The NPC register is found at ADDR. */
536 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
539 collect_register (regcache
, SPU_PC_REGNUM
, buf
);
540 store_ppc_memory (addr
, buf
, 4);
543 /* The GPRs are found in the "regs" spufs file. */
544 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
546 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
550 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
551 collect_register (regcache
, i
, buf
+ i
*16);
553 sprintf (annex
, "%d/regs", fd
);
554 spu_proc_xfer_spu (annex
, NULL
, buf
, 0, sizeof buf
);
558 /* Copy LEN bytes from inferior's memory starting at MEMADDR
559 to debugger memory starting at MYADDR. */
561 spu_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
565 char annex
[32], lslr_annex
[32], buf
[32];
568 /* We must be stopped on a spu_run system call. */
569 if (!parse_spufs_run (&fd
, &addr
))
572 /* Use the "mem" spufs file to access SPU local store. */
573 sprintf (annex
, "%d/mem", fd
);
574 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
, len
);
576 return ret
== len
? 0 : EIO
;
578 /* SPU local store access wraps the address around at the
579 local store limit. We emulate this here. To avoid needing
580 an extra access to retrieve the LSLR, we only do that after
581 trying the original address first, and getting end-of-file. */
582 sprintf (lslr_annex
, "%d/lslr", fd
);
583 memset (buf
, 0, sizeof buf
);
584 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
588 lslr
= strtoul (buf
, NULL
, 16);
589 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
& lslr
, len
);
591 return ret
== len
? 0 : EIO
;
594 /* Copy LEN bytes of data from debugger memory at MYADDR
595 to inferior's memory at MEMADDR.
596 On failure (cannot write the inferior)
597 returns the value of errno. */
599 spu_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
603 char annex
[32], lslr_annex
[32], buf
[32];
606 /* We must be stopped on a spu_run system call. */
607 if (!parse_spufs_run (&fd
, &addr
))
610 /* Use the "mem" spufs file to access SPU local store. */
611 sprintf (annex
, "%d/mem", fd
);
612 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
, len
);
614 return ret
== len
? 0 : EIO
;
616 /* SPU local store access wraps the address around at the
617 local store limit. We emulate this here. To avoid needing
618 an extra access to retrieve the LSLR, we only do that after
619 trying the original address first, and getting end-of-file. */
620 sprintf (lslr_annex
, "%d/lslr", fd
);
621 memset (buf
, 0, sizeof buf
);
622 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
626 lslr
= strtoul (buf
, NULL
, 16);
627 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
& lslr
, len
);
629 return ret
== len
? 0 : EIO
;
632 /* Look up special symbols -- unneded here. */
634 spu_look_up_symbols (void)
638 /* Send signal to inferior. */
640 spu_request_interrupt (void)
642 struct thread_info
*thr
= get_first_thread ();
644 syscall (SYS_tkill
, lwpid_of (thr
), SIGINT
);
647 /* Implementation of the target_ops method "sw_breakpoint_from_kind". */
649 static const gdb_byte
*
650 spu_sw_breakpoint_from_kind (int kind
, int *size
)
652 *size
= sizeof breakpoint
;
656 static struct target_ops spu_target_ops
= {
658 NULL
, /* post_create_inferior */
669 NULL
, /* prepare_to_access_memory */
670 NULL
, /* done_accessing_memory */
674 spu_request_interrupt
,
676 NULL
, /* supports_z_point_type */
679 NULL
, /* stopped_by_sw_breakpoint */
680 NULL
, /* supports_stopped_by_sw_breakpoint */
681 NULL
, /* stopped_by_hw_breakpoint */
682 NULL
, /* supports_stopped_by_hw_breakpoint */
683 NULL
, /* supports_hardware_single_step */
689 hostio_last_error_from_errno
,
690 NULL
, /* qxfer_osdata */
691 NULL
, /* qxfer_siginfo */
692 NULL
, /* supports_non_stop */
694 NULL
, /* start_non_stop */
695 NULL
, /* supports_multi_process */
696 NULL
, /* supports_fork_events */
697 NULL
, /* supports_vfork_events */
698 NULL
, /* supports_exec_events */
699 NULL
, /* handle_new_gdb_connection */
700 NULL
, /* handle_monitor_command */
701 NULL
, /* core_of_thread */
702 NULL
, /* read_loadmap */
703 NULL
, /* process_qsupported */
704 NULL
, /* supports_tracepoints */
707 NULL
, /* thread_stopped */
708 NULL
, /* get_tib_address */
709 NULL
, /* pause_all */
710 NULL
, /* unpause_all */
711 NULL
, /* stabilize_threads */
712 NULL
, /* install_fast_tracepoint_jump_pad */
714 NULL
, /* supports_disable_randomization */
715 NULL
, /* get_min_fast_tracepoint_insn_len */
716 NULL
, /* qxfer_libraries_svr4 */
717 NULL
, /* support_agent */
718 NULL
, /* support_btrace */
719 NULL
, /* enable_btrace */
720 NULL
, /* disable_btrace */
721 NULL
, /* read_btrace */
722 NULL
, /* read_btrace_conf */
723 NULL
, /* supports_range_stepping */
724 NULL
, /* pid_to_exec_file */
725 NULL
, /* multifs_open */
726 NULL
, /* multifs_unlink */
727 NULL
, /* multifs_readlink */
728 NULL
, /* breakpoint_kind_from_pc */
729 spu_sw_breakpoint_from_kind
,
733 initialize_low (void)
735 set_target_ops (&spu_target_ops
);
736 init_registers_spu ();