1 /* Low level interface to SPUs, for the remote server for GDB.
2 Copyright (C) 2006-2014 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>
29 #include <sys/syscall.h>
30 #include "filestuff.h"
33 /* Some older glibc versions do not define this. */
35 #define __WNOTHREAD 0x20000000 /* Don't wait on children of other
36 threads in this group */
39 #define PTRACE_TYPE_RET long
40 #define PTRACE_TYPE_ARG3 long
42 /* Number of registers. */
43 #define SPU_NUM_REGS 130
44 #define SPU_NUM_CORE_REGS 128
46 /* Special registers. */
47 #define SPU_ID_REGNUM 128
48 #define SPU_PC_REGNUM 129
50 /* PPU side system calls. */
51 #define INSTR_SC 0x44000002
52 #define NR_spu_run 0x0116
54 /* These are used in remote-utils.c. */
55 int using_threads
= 0;
57 /* Defined in auto-generated file reg-spu.c. */
58 void init_registers_spu (void);
59 extern const struct target_desc
*tdesc_spu
;
61 /* Fetch PPU register REGNO. */
63 fetch_ppc_register (int regno
)
67 int tid
= ptid_get_lwp (current_ptid
);
70 /* If running as a 32-bit process on a 64-bit system, we attempt
71 to get the full 64-bit register content of the target process.
72 If the PPC special ptrace call fails, we're on a 32-bit system;
73 just fall through to the regular ptrace call in that case. */
78 ptrace (PPC_PTRACE_PEEKUSR_3264
, tid
,
79 (PTRACE_TYPE_ARG3
) (regno
* 8), buf
);
81 ptrace (PPC_PTRACE_PEEKUSR_3264
, tid
,
82 (PTRACE_TYPE_ARG3
) (regno
* 8 + 4), buf
+ 4);
84 return (CORE_ADDR
) *(unsigned long long *)buf
;
89 res
= ptrace (PT_READ_U
, tid
,
90 (PTRACE_TYPE_ARG3
) (regno
* sizeof (PTRACE_TYPE_RET
)), 0);
94 sprintf (mess
, "reading PPC register #%d", regno
);
95 perror_with_name (mess
);
98 return (CORE_ADDR
) (unsigned long) res
;
101 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
103 fetch_ppc_memory_1 (int tid
, CORE_ADDR memaddr
, PTRACE_TYPE_RET
*word
)
107 #ifndef __powerpc64__
110 unsigned long long addr_8
= (unsigned long long) memaddr
;
111 ptrace (PPC_PTRACE_PEEKTEXT_3264
, tid
, (PTRACE_TYPE_ARG3
) &addr_8
, word
);
115 *word
= ptrace (PT_READ_I
, tid
, (PTRACE_TYPE_ARG3
) (size_t) memaddr
, 0);
120 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
122 store_ppc_memory_1 (int tid
, CORE_ADDR memaddr
, PTRACE_TYPE_RET word
)
126 #ifndef __powerpc64__
129 unsigned long long addr_8
= (unsigned long long) memaddr
;
130 ptrace (PPC_PTRACE_POKEDATA_3264
, tid
, (PTRACE_TYPE_ARG3
) &addr_8
, word
);
134 ptrace (PT_WRITE_D
, tid
, (PTRACE_TYPE_ARG3
) (size_t) memaddr
, word
);
139 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
141 fetch_ppc_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
145 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
146 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
147 / sizeof (PTRACE_TYPE_RET
));
148 PTRACE_TYPE_RET
*buffer
;
150 int tid
= ptid_get_lwp (current_ptid
);
152 buffer
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
153 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
154 if ((ret
= fetch_ppc_memory_1 (tid
, addr
, &buffer
[i
])) != 0)
158 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
164 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
166 store_ppc_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
170 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
171 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
172 / sizeof (PTRACE_TYPE_RET
));
173 PTRACE_TYPE_RET
*buffer
;
175 int tid
= ptid_get_lwp (current_ptid
);
177 buffer
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
179 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_TYPE_RET
))
180 if ((ret
= fetch_ppc_memory_1 (tid
, addr
, &buffer
[0])) != 0)
184 if ((ret
= fetch_ppc_memory_1 (tid
, addr
+ (count
- 1)
185 * sizeof (PTRACE_TYPE_RET
),
186 &buffer
[count
- 1])) != 0)
189 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
192 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
193 if ((ret
= store_ppc_memory_1 (tid
, addr
, buffer
[i
])) != 0)
200 /* If the PPU thread is currently stopped on a spu_run system call,
201 return to FD and ADDR the file handle and NPC parameter address
202 used with the system call. Return non-zero if successful. */
204 parse_spufs_run (int *fd
, CORE_ADDR
*addr
)
207 CORE_ADDR pc
= fetch_ppc_register (32); /* nip */
209 /* Fetch instruction preceding current NIP. */
210 if (fetch_ppc_memory (pc
-4, (char *) &insn
, 4) != 0)
212 /* It should be a "sc" instruction. */
213 if (insn
!= INSTR_SC
)
215 /* System call number should be NR_spu_run. */
216 if (fetch_ppc_register (0) != NR_spu_run
)
219 /* Register 3 contains fd, register 4 the NPC param pointer. */
220 *fd
= fetch_ppc_register (34); /* orig_gpr3 */
221 *addr
= fetch_ppc_register (4);
226 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
227 using the /proc file system. */
229 spu_proc_xfer_spu (const char *annex
, unsigned char *readbuf
,
230 const unsigned char *writebuf
,
231 CORE_ADDR offset
, int len
)
240 sprintf (buf
, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid
), annex
);
241 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
246 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
253 ret
= write (fd
, writebuf
, (size_t) len
);
255 ret
= read (fd
, readbuf
, (size_t) len
);
262 /* Start an inferior process and returns its pid.
263 ALLARGS is a vector of program-name and args. */
265 spu_create_inferior (char *program
, char **allargs
)
269 struct process_info
*proc
;
273 perror_with_name ("fork");
278 ptrace (PTRACE_TRACEME
, 0, 0, 0);
282 execv (program
, allargs
);
284 execvp (program
, allargs
);
286 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
292 proc
= add_process (pid
, 0);
293 proc
->tdesc
= tdesc_spu
;
295 ptid
= ptid_build (pid
, pid
, 0);
296 add_thread (ptid
, NULL
);
300 /* Attach to an inferior process. */
302 spu_attach (unsigned long pid
)
305 struct process_info
*proc
;
307 if (ptrace (PTRACE_ATTACH
, pid
, 0, 0) != 0)
309 fprintf (stderr
, "Cannot attach to process %ld: %s (%d)\n", pid
,
310 strerror (errno
), errno
);
315 proc
= add_process (pid
, 1);
316 proc
->tdesc
= tdesc_spu
;
317 ptid
= ptid_build (pid
, pid
, 0);
318 add_thread (ptid
, NULL
);
322 /* Kill the inferior process. */
327 struct process_info
*process
= find_process_pid (pid
);
331 ptrace (PTRACE_KILL
, pid
, 0, 0);
334 ret
= waitpid (pid
, &status
, 0);
335 if (WIFEXITED (status
) || WIFSIGNALED (status
))
337 } while (ret
!= -1 || errno
!= ECHILD
);
340 remove_process (process
);
344 /* Detach from inferior process. */
348 struct process_info
*process
= find_process_pid (pid
);
352 ptrace (PTRACE_DETACH
, pid
, 0, 0);
355 remove_process (process
);
360 spu_mourn (struct process_info
*process
)
362 remove_process (process
);
371 ret
= waitpid (pid
, &status
, 0);
372 if (WIFEXITED (status
) || WIFSIGNALED (status
))
374 } while (ret
!= -1 || errno
!= ECHILD
);
377 /* Return nonzero if the given thread is still alive. */
379 spu_thread_alive (ptid_t ptid
)
381 return ptid_equal (ptid
, current_ptid
);
384 /* Resume process. */
386 spu_resume (struct thread_resume
*resume_info
, size_t n
)
390 for (i
= 0; i
< n
; i
++)
391 if (ptid_equal (resume_info
[i
].thread
, minus_one_ptid
)
392 || ptid_equal (resume_info
[i
].thread
, current_ptid
))
398 /* We don't support hardware single-stepping right now, assume
399 GDB knows to use software single-stepping. */
400 if (resume_info
[i
].kind
== resume_step
)
401 fprintf (stderr
, "Hardware single-step not supported.\n");
403 regcache_invalidate ();
406 ptrace (PTRACE_CONT
, ptid_get_lwp (current_ptid
), 0, resume_info
[i
].sig
);
408 perror_with_name ("ptrace");
411 /* Wait for process, returns status. */
413 spu_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
415 int pid
= ptid_get_pid (ptid
);
421 ret
= waitpid (pid
, &w
, WNOHANG
| __WALL
| __WNOTHREAD
);
426 perror_with_name ("waitpid");
434 /* On the first wait, continue running the inferior until we are
435 blocked inside an spu_run system call. */
441 while (!parse_spufs_run (&fd
, &addr
))
443 ptrace (PT_SYSCALL
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
444 waitpid (pid
, NULL
, __WALL
| __WNOTHREAD
);
450 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
451 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
452 ourstatus
->value
.integer
= WEXITSTATUS (w
);
454 return pid_to_ptid (ret
);
456 else if (!WIFSTOPPED (w
))
458 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
459 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
460 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (w
));
462 return pid_to_ptid (ret
);
465 /* After attach, we may have received a SIGSTOP. Do not return this
466 as signal to GDB, or else it will try to continue with SIGSTOP ... */
469 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
470 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
471 return ptid_build (ret
, ret
, 0);
474 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
475 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
476 return ptid_build (ret
, ret
, 0);
479 /* Fetch inferior registers. */
481 spu_fetch_registers (struct regcache
*regcache
, int regno
)
486 /* We must be stopped on a spu_run system call. */
487 if (!parse_spufs_run (&fd
, &addr
))
490 /* The ID register holds the spufs file handle. */
491 if (regno
== -1 || regno
== SPU_ID_REGNUM
)
492 supply_register (regcache
, SPU_ID_REGNUM
, (char *)&fd
);
494 /* The NPC register is found at ADDR. */
495 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
498 if (fetch_ppc_memory (addr
, buf
, 4) == 0)
499 supply_register (regcache
, SPU_PC_REGNUM
, buf
);
502 /* The GPRs are found in the "regs" spufs file. */
503 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
505 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
509 sprintf (annex
, "%d/regs", fd
);
510 if (spu_proc_xfer_spu (annex
, buf
, NULL
, 0, sizeof buf
) == sizeof buf
)
511 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
512 supply_register (regcache
, i
, buf
+ i
*16);
516 /* Store inferior registers. */
518 spu_store_registers (struct regcache
*regcache
, int regno
)
523 /* ??? Some callers use 0 to mean all registers. */
527 /* We must be stopped on a spu_run system call. */
528 if (!parse_spufs_run (&fd
, &addr
))
531 /* The NPC register is found at ADDR. */
532 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
535 collect_register (regcache
, SPU_PC_REGNUM
, buf
);
536 store_ppc_memory (addr
, buf
, 4);
539 /* The GPRs are found in the "regs" spufs file. */
540 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
542 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
546 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
547 collect_register (regcache
, i
, buf
+ i
*16);
549 sprintf (annex
, "%d/regs", fd
);
550 spu_proc_xfer_spu (annex
, NULL
, buf
, 0, sizeof buf
);
554 /* Copy LEN bytes from inferior's memory starting at MEMADDR
555 to debugger memory starting at MYADDR. */
557 spu_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
561 char annex
[32], lslr_annex
[32], buf
[32];
564 /* We must be stopped on a spu_run system call. */
565 if (!parse_spufs_run (&fd
, &addr
))
568 /* Use the "mem" spufs file to access SPU local store. */
569 sprintf (annex
, "%d/mem", fd
);
570 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
, len
);
572 return ret
== len
? 0 : EIO
;
574 /* SPU local store access wraps the address around at the
575 local store limit. We emulate this here. To avoid needing
576 an extra access to retrieve the LSLR, we only do that after
577 trying the original address first, and getting end-of-file. */
578 sprintf (lslr_annex
, "%d/lslr", fd
);
579 memset (buf
, 0, sizeof buf
);
580 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
584 lslr
= strtoul (buf
, NULL
, 16);
585 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
& lslr
, len
);
587 return ret
== len
? 0 : EIO
;
590 /* Copy LEN bytes of data from debugger memory at MYADDR
591 to inferior's memory at MEMADDR.
592 On failure (cannot write the inferior)
593 returns the value of errno. */
595 spu_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
599 char annex
[32], lslr_annex
[32], buf
[32];
602 /* We must be stopped on a spu_run system call. */
603 if (!parse_spufs_run (&fd
, &addr
))
606 /* Use the "mem" spufs file to access SPU local store. */
607 sprintf (annex
, "%d/mem", fd
);
608 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
, len
);
610 return ret
== len
? 0 : EIO
;
612 /* SPU local store access wraps the address around at the
613 local store limit. We emulate this here. To avoid needing
614 an extra access to retrieve the LSLR, we only do that after
615 trying the original address first, and getting end-of-file. */
616 sprintf (lslr_annex
, "%d/lslr", fd
);
617 memset (buf
, 0, sizeof buf
);
618 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
622 lslr
= strtoul (buf
, NULL
, 16);
623 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
& lslr
, len
);
625 return ret
== len
? 0 : EIO
;
628 /* Look up special symbols -- unneded here. */
630 spu_look_up_symbols (void)
634 /* Send signal to inferior. */
636 spu_request_interrupt (void)
638 syscall (SYS_tkill
, ptid_get_lwp (current_ptid
), SIGINT
);
641 static struct target_ops spu_target_ops
= {
653 NULL
, /* prepare_to_access_memory */
654 NULL
, /* done_accessing_memory */
658 spu_request_interrupt
,
660 NULL
, /* supports_z_point_type */
668 hostio_last_error_from_errno
,
672 initialize_low (void)
674 static const unsigned char breakpoint
[] = { 0x00, 0x00, 0x3f, 0xff };
676 set_target_ops (&spu_target_ops
);
677 set_breakpoint_data (breakpoint
, sizeof breakpoint
);
678 init_registers_spu ();