1 /* Low level interface to SPUs, for the remote server for GDB.
2 Copyright (C) 2006, 2007, 2008, 2009, 2010 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/>. */
25 #include <sys/ptrace.h>
31 #include <sys/syscall.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 /* Get current thread ID (Linux task ID). */
55 #define current_ptid ((struct inferior_list_entry *)current_inferior)->id
57 /* These are used in remote-utils.c. */
58 int using_threads
= 0;
60 /* Defined in auto-generated file reg-spu.c. */
61 void init_registers_spu (void);
64 /* Fetch PPU register REGNO. */
66 fetch_ppc_register (int regno
)
70 int tid
= ptid_get_lwp (current_ptid
);
73 /* If running as a 32-bit process on a 64-bit system, we attempt
74 to get the full 64-bit register content of the target process.
75 If the PPC special ptrace call fails, we're on a 32-bit system;
76 just fall through to the regular ptrace call in that case. */
81 ptrace (PPC_PTRACE_PEEKUSR_3264
, tid
,
82 (PTRACE_TYPE_ARG3
) (regno
* 8), buf
);
84 ptrace (PPC_PTRACE_PEEKUSR_3264
, tid
,
85 (PTRACE_TYPE_ARG3
) (regno
* 8 + 4), buf
+ 4);
87 return (CORE_ADDR
) *(unsigned long long *)buf
;
92 res
= ptrace (PT_READ_U
, tid
,
93 (PTRACE_TYPE_ARG3
) (regno
* sizeof (PTRACE_TYPE_RET
)), 0);
97 sprintf (mess
, "reading PPC register #%d", regno
);
98 perror_with_name (mess
);
101 return (CORE_ADDR
) (unsigned long) res
;
104 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
106 fetch_ppc_memory_1 (int tid
, CORE_ADDR memaddr
, PTRACE_TYPE_RET
*word
)
110 #ifndef __powerpc64__
113 unsigned long long addr_8
= (unsigned long long) memaddr
;
114 ptrace (PPC_PTRACE_PEEKTEXT_3264
, tid
, (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 (PPC_PTRACE_POKEDATA_3264
, tid
, (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
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
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
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
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, buf
, 4) != 0)
215 /* It should be a "sc" instruction. */
216 if (*(unsigned int *)buf
!= 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
)
275 perror_with_name ("fork");
279 ptrace (PTRACE_TRACEME
, 0, 0, 0);
283 execv (program
, allargs
);
285 execvp (program
, allargs
);
287 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
293 add_process (pid
, 0);
295 ptid
= ptid_build (pid
, pid
, 0);
296 add_thread (ptid
, NULL
);
300 /* Attach to an inferior process. */
302 spu_attach (unsigned long pid
)
306 if (ptrace (PTRACE_ATTACH
, pid
, 0, 0) != 0)
308 fprintf (stderr
, "Cannot attach to process %ld: %s (%d)\n", pid
,
309 strerror (errno
), errno
);
314 add_process (pid
, 1);
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
);
367 struct process_info
*process
;
369 process
= find_process_pid (pid
);
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
)
393 for (i
= 0; i
< n
; i
++)
394 if (ptid_equal (resume_info
[i
].thread
, minus_one_ptid
)
395 || ptid_equal (resume_info
[i
].thread
, current_ptid
))
401 /* We don't support hardware single-stepping right now, assume
402 GDB knows to use software single-stepping. */
403 if (resume_info
[i
].kind
== resume_step
)
404 fprintf (stderr
, "Hardware single-step not supported.\n");
406 regcache_invalidate ();
409 ptrace (PTRACE_CONT
, ptid_get_lwp (current_ptid
), 0, resume_info
[i
].sig
);
411 perror_with_name ("ptrace");
414 /* Wait for process, returns status. */
416 spu_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
418 int pid
= ptid_get_pid (ptid
);
424 ret
= waitpid (pid
, &w
, WNOHANG
| __WALL
| __WNOTHREAD
);
429 perror_with_name ("waitpid");
437 /* On the first wait, continue running the inferior until we are
438 blocked inside an spu_run system call. */
444 while (!parse_spufs_run (&fd
, &addr
))
446 ptrace (PT_SYSCALL
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
447 waitpid (pid
, NULL
, __WALL
| __WNOTHREAD
);
453 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
454 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
455 ourstatus
->value
.integer
= WEXITSTATUS (w
);
457 return pid_to_ptid (ret
);
459 else if (!WIFSTOPPED (w
))
461 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
462 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
463 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (w
));
465 return pid_to_ptid (ret
);
468 /* After attach, we may have received a SIGSTOP. Do not return this
469 as signal to GDB, or else it will try to continue with SIGSTOP ... */
472 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
473 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
474 return ptid_build (ret
, ret
, 0);
477 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
478 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (w
));
479 return ptid_build (ret
, ret
, 0);
482 /* Fetch inferior registers. */
484 spu_fetch_registers (struct regcache
*regcache
, int regno
)
489 /* We must be stopped on a spu_run system call. */
490 if (!parse_spufs_run (&fd
, &addr
))
493 /* The ID register holds the spufs file handle. */
494 if (regno
== -1 || regno
== SPU_ID_REGNUM
)
495 supply_register (regcache
, SPU_ID_REGNUM
, (char *)&fd
);
497 /* The NPC register is found at ADDR. */
498 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
501 if (fetch_ppc_memory (addr
, buf
, 4) == 0)
502 supply_register (regcache
, SPU_PC_REGNUM
, buf
);
505 /* The GPRs are found in the "regs" spufs file. */
506 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
508 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
512 sprintf (annex
, "%d/regs", fd
);
513 if (spu_proc_xfer_spu (annex
, buf
, NULL
, 0, sizeof buf
) == sizeof buf
)
514 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
515 supply_register (regcache
, i
, buf
+ i
*16);
519 /* Store inferior registers. */
521 spu_store_registers (struct regcache
*regcache
, int regno
)
526 /* ??? Some callers use 0 to mean all registers. */
530 /* We must be stopped on a spu_run system call. */
531 if (!parse_spufs_run (&fd
, &addr
))
534 /* The NPC register is found at ADDR. */
535 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
538 collect_register (regcache
, SPU_PC_REGNUM
, buf
);
539 store_ppc_memory (addr
, buf
, 4);
542 /* The GPRs are found in the "regs" spufs file. */
543 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
545 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
549 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
550 collect_register (regcache
, i
, buf
+ i
*16);
552 sprintf (annex
, "%d/regs", fd
);
553 spu_proc_xfer_spu (annex
, NULL
, buf
, 0, sizeof buf
);
557 /* Copy LEN bytes from inferior's memory starting at MEMADDR
558 to debugger memory starting at MYADDR. */
560 spu_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
564 char annex
[32], lslr_annex
[32], buf
[32];
567 /* We must be stopped on a spu_run system call. */
568 if (!parse_spufs_run (&fd
, &addr
))
571 /* Use the "mem" spufs file to access SPU local store. */
572 sprintf (annex
, "%d/mem", fd
);
573 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
, len
);
575 return ret
== len
? 0 : EIO
;
577 /* SPU local store access wraps the address around at the
578 local store limit. We emulate this here. To avoid needing
579 an extra access to retrieve the LSLR, we only do that after
580 trying the original address first, and getting end-of-file. */
581 sprintf (lslr_annex
, "%d/lslr", fd
);
582 memset (buf
, 0, sizeof buf
);
583 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
587 lslr
= strtoul (buf
, NULL
, 16);
588 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
& lslr
, len
);
590 return ret
== len
? 0 : EIO
;
593 /* Copy LEN bytes of data from debugger memory at MYADDR
594 to inferior's memory at MEMADDR.
595 On failure (cannot write the inferior)
596 returns the value of errno. */
598 spu_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
602 char annex
[32], lslr_annex
[32], buf
[32];
605 /* We must be stopped on a spu_run system call. */
606 if (!parse_spufs_run (&fd
, &addr
))
609 /* Use the "mem" spufs file to access SPU local store. */
610 sprintf (annex
, "%d/mem", fd
);
611 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
, len
);
613 return ret
== len
? 0 : EIO
;
615 /* SPU local store access wraps the address around at the
616 local store limit. We emulate this here. To avoid needing
617 an extra access to retrieve the LSLR, we only do that after
618 trying the original address first, and getting end-of-file. */
619 sprintf (lslr_annex
, "%d/lslr", fd
);
620 memset (buf
, 0, sizeof buf
);
621 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
625 lslr
= strtoul (buf
, NULL
, 16);
626 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
& lslr
, len
);
628 return ret
== len
? 0 : EIO
;
631 /* Look up special symbols -- unneded here. */
633 spu_look_up_symbols (void)
637 /* Send signal to inferior. */
639 spu_request_interrupt (void)
641 syscall (SYS_tkill
, ptid_get_lwp (current_ptid
), SIGINT
);
644 static struct target_ops spu_target_ops
= {
656 NULL
, /* prepare_to_access_memory */
657 NULL
, /* done_accessing_memory */
661 spu_request_interrupt
,
670 hostio_last_error_from_errno
,
674 initialize_low (void)
676 static const unsigned char breakpoint
[] = { 0x00, 0x00, 0x3f, 0xff };
678 set_target_ops (&spu_target_ops
);
679 set_breakpoint_data (breakpoint
, sizeof breakpoint
);
680 init_registers_spu ();