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/>. */
25 #include <sys/ptrace.h>
31 #include <sys/syscall.h>
32 #include "filestuff.h"
35 /* Some older glibc versions do not define this. */
37 #define __WNOTHREAD 0x20000000 /* Don't wait on children of other
38 threads in this group */
41 #define PTRACE_TYPE_RET long
42 #define PTRACE_TYPE_ARG3 long
44 /* Number of registers. */
45 #define SPU_NUM_REGS 130
46 #define SPU_NUM_CORE_REGS 128
48 /* Special registers. */
49 #define SPU_ID_REGNUM 128
50 #define SPU_PC_REGNUM 129
52 /* PPU side system calls. */
53 #define INSTR_SC 0x44000002
54 #define NR_spu_run 0x0116
56 /* These are used in remote-utils.c. */
57 int using_threads
= 0;
59 /* Defined in auto-generated file reg-spu.c. */
60 void init_registers_spu (void);
61 extern const struct target_desc
*tdesc_spu
;
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 (PPC_PTRACE_PEEKUSR_3264
, tid
,
81 (PTRACE_TYPE_ARG3
) (regno
* 8), buf
);
83 ptrace (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 (PPC_PTRACE_PEEKTEXT_3264
, tid
, (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 (PPC_PTRACE_POKEDATA_3264
, tid
, (PTRACE_TYPE_ARG3
) &addr_8
, word
);
136 ptrace (PT_WRITE_D
, tid
, (PTRACE_TYPE_ARG3
) (size_t) memaddr
, word
);
141 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
143 fetch_ppc_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
147 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
148 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
149 / sizeof (PTRACE_TYPE_RET
));
150 PTRACE_TYPE_RET
*buffer
;
152 int tid
= ptid_get_lwp (current_ptid
);
154 buffer
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
155 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
156 if ((ret
= fetch_ppc_memory_1 (tid
, addr
, &buffer
[i
])) != 0)
160 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
166 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
168 store_ppc_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
172 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
173 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
174 / sizeof (PTRACE_TYPE_RET
));
175 PTRACE_TYPE_RET
*buffer
;
177 int tid
= ptid_get_lwp (current_ptid
);
179 buffer
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
181 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_TYPE_RET
))
182 if ((ret
= fetch_ppc_memory_1 (tid
, addr
, &buffer
[0])) != 0)
186 if ((ret
= fetch_ppc_memory_1 (tid
, addr
+ (count
- 1)
187 * sizeof (PTRACE_TYPE_RET
),
188 &buffer
[count
- 1])) != 0)
191 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
194 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
195 if ((ret
= store_ppc_memory_1 (tid
, addr
, buffer
[i
])) != 0)
202 /* If the PPU thread is currently stopped on a spu_run system call,
203 return to FD and ADDR the file handle and NPC parameter address
204 used with the system call. Return non-zero if successful. */
206 parse_spufs_run (int *fd
, CORE_ADDR
*addr
)
209 CORE_ADDR pc
= fetch_ppc_register (32); /* nip */
211 /* Fetch instruction preceding current NIP. */
212 if (fetch_ppc_memory (pc
-4, (char *) &insn
, 4) != 0)
214 /* It should be a "sc" instruction. */
215 if (insn
!= INSTR_SC
)
217 /* System call number should be NR_spu_run. */
218 if (fetch_ppc_register (0) != NR_spu_run
)
221 /* Register 3 contains fd, register 4 the NPC param pointer. */
222 *fd
= fetch_ppc_register (34); /* orig_gpr3 */
223 *addr
= fetch_ppc_register (4);
228 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
229 using the /proc file system. */
231 spu_proc_xfer_spu (const char *annex
, unsigned char *readbuf
,
232 const unsigned char *writebuf
,
233 CORE_ADDR offset
, int len
)
242 sprintf (buf
, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid
), annex
);
243 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
248 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
255 ret
= write (fd
, writebuf
, (size_t) len
);
257 ret
= read (fd
, readbuf
, (size_t) len
);
264 /* Start an inferior process and returns its pid.
265 ALLARGS is a vector of program-name and args. */
267 spu_create_inferior (char *program
, char **allargs
)
271 struct process_info
*proc
;
275 perror_with_name ("fork");
280 ptrace (PTRACE_TRACEME
, 0, 0, 0);
284 execv (program
, allargs
);
286 execvp (program
, allargs
);
288 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
294 proc
= add_process (pid
, 0);
295 proc
->tdesc
= tdesc_spu
;
297 ptid
= ptid_build (pid
, pid
, 0);
298 add_thread (ptid
, NULL
);
302 /* Attach to an inferior process. */
304 spu_attach (unsigned long pid
)
307 struct process_info
*proc
;
309 if (ptrace (PTRACE_ATTACH
, pid
, 0, 0) != 0)
311 fprintf (stderr
, "Cannot attach to process %ld: %s (%d)\n", pid
,
312 strerror (errno
), errno
);
317 proc
= add_process (pid
, 1);
318 proc
->tdesc
= tdesc_spu
;
319 ptid
= ptid_build (pid
, pid
, 0);
320 add_thread (ptid
, NULL
);
324 /* Kill the inferior process. */
329 struct process_info
*process
= find_process_pid (pid
);
333 ptrace (PTRACE_KILL
, pid
, 0, 0);
336 ret
= waitpid (pid
, &status
, 0);
337 if (WIFEXITED (status
) || WIFSIGNALED (status
))
339 } while (ret
!= -1 || errno
!= ECHILD
);
342 remove_process (process
);
346 /* Detach from inferior process. */
350 struct process_info
*process
= find_process_pid (pid
);
354 ptrace (PTRACE_DETACH
, pid
, 0, 0);
357 remove_process (process
);
362 spu_mourn (struct process_info
*process
)
364 remove_process (process
);
373 ret
= waitpid (pid
, &status
, 0);
374 if (WIFEXITED (status
) || WIFSIGNALED (status
))
376 } while (ret
!= -1 || errno
!= ECHILD
);
379 /* Return nonzero if the given thread is still alive. */
381 spu_thread_alive (ptid_t ptid
)
383 return ptid_equal (ptid
, current_ptid
);
386 /* Resume process. */
388 spu_resume (struct thread_resume
*resume_info
, size_t n
)
392 for (i
= 0; i
< n
; i
++)
393 if (ptid_equal (resume_info
[i
].thread
, minus_one_ptid
)
394 || ptid_equal (resume_info
[i
].thread
, current_ptid
))
400 /* We don't support hardware single-stepping right now, assume
401 GDB knows to use software single-stepping. */
402 if (resume_info
[i
].kind
== resume_step
)
403 fprintf (stderr
, "Hardware single-step not supported.\n");
405 regcache_invalidate ();
408 ptrace (PTRACE_CONT
, ptid_get_lwp (current_ptid
), 0, resume_info
[i
].sig
);
410 perror_with_name ("ptrace");
413 /* Wait for process, returns status. */
415 spu_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
417 int pid
= ptid_get_pid (ptid
);
423 ret
= waitpid (pid
, &w
, WNOHANG
| __WALL
| __WNOTHREAD
);
428 perror_with_name ("waitpid");
436 /* On the first wait, continue running the inferior until we are
437 blocked inside an spu_run system call. */
443 while (!parse_spufs_run (&fd
, &addr
))
445 ptrace (PT_SYSCALL
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
446 waitpid (pid
, NULL
, __WALL
| __WNOTHREAD
);
452 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
453 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
454 ourstatus
->value
.integer
= WEXITSTATUS (w
);
456 return pid_to_ptid (ret
);
458 else if (!WIFSTOPPED (w
))
460 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
461 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
462 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (w
));
464 return pid_to_ptid (ret
);
467 /* After attach, we may have received a SIGSTOP. Do not return this
468 as signal to GDB, or else it will try to continue with SIGSTOP ... */
471 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
472 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
473 return ptid_build (ret
, ret
, 0);
476 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
477 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
478 return ptid_build (ret
, ret
, 0);
481 /* Fetch inferior registers. */
483 spu_fetch_registers (struct regcache
*regcache
, int regno
)
488 /* We must be stopped on a spu_run system call. */
489 if (!parse_spufs_run (&fd
, &addr
))
492 /* The ID register holds the spufs file handle. */
493 if (regno
== -1 || regno
== SPU_ID_REGNUM
)
494 supply_register (regcache
, SPU_ID_REGNUM
, (char *)&fd
);
496 /* The NPC register is found at ADDR. */
497 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
500 if (fetch_ppc_memory (addr
, buf
, 4) == 0)
501 supply_register (regcache
, SPU_PC_REGNUM
, buf
);
504 /* The GPRs are found in the "regs" spufs file. */
505 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
507 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
511 sprintf (annex
, "%d/regs", fd
);
512 if (spu_proc_xfer_spu (annex
, buf
, NULL
, 0, sizeof buf
) == sizeof buf
)
513 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
514 supply_register (regcache
, i
, buf
+ i
*16);
518 /* Store inferior registers. */
520 spu_store_registers (struct regcache
*regcache
, int regno
)
525 /* ??? Some callers use 0 to mean all registers. */
529 /* We must be stopped on a spu_run system call. */
530 if (!parse_spufs_run (&fd
, &addr
))
533 /* The NPC register is found at ADDR. */
534 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
537 collect_register (regcache
, SPU_PC_REGNUM
, buf
);
538 store_ppc_memory (addr
, buf
, 4);
541 /* The GPRs are found in the "regs" spufs file. */
542 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
544 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
548 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
549 collect_register (regcache
, i
, buf
+ i
*16);
551 sprintf (annex
, "%d/regs", fd
);
552 spu_proc_xfer_spu (annex
, NULL
, buf
, 0, sizeof buf
);
556 /* Copy LEN bytes from inferior's memory starting at MEMADDR
557 to debugger memory starting at MYADDR. */
559 spu_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
563 char annex
[32], lslr_annex
[32], buf
[32];
566 /* We must be stopped on a spu_run system call. */
567 if (!parse_spufs_run (&fd
, &addr
))
570 /* Use the "mem" spufs file to access SPU local store. */
571 sprintf (annex
, "%d/mem", fd
);
572 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
, len
);
574 return ret
== len
? 0 : EIO
;
576 /* SPU local store access wraps the address around at the
577 local store limit. We emulate this here. To avoid needing
578 an extra access to retrieve the LSLR, we only do that after
579 trying the original address first, and getting end-of-file. */
580 sprintf (lslr_annex
, "%d/lslr", fd
);
581 memset (buf
, 0, sizeof buf
);
582 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
586 lslr
= strtoul (buf
, NULL
, 16);
587 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
& lslr
, len
);
589 return ret
== len
? 0 : EIO
;
592 /* Copy LEN bytes of data from debugger memory at MYADDR
593 to inferior's memory at MEMADDR.
594 On failure (cannot write the inferior)
595 returns the value of errno. */
597 spu_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
601 char annex
[32], lslr_annex
[32], buf
[32];
604 /* We must be stopped on a spu_run system call. */
605 if (!parse_spufs_run (&fd
, &addr
))
608 /* Use the "mem" spufs file to access SPU local store. */
609 sprintf (annex
, "%d/mem", fd
);
610 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
, len
);
612 return ret
== len
? 0 : EIO
;
614 /* SPU local store access wraps the address around at the
615 local store limit. We emulate this here. To avoid needing
616 an extra access to retrieve the LSLR, we only do that after
617 trying the original address first, and getting end-of-file. */
618 sprintf (lslr_annex
, "%d/lslr", fd
);
619 memset (buf
, 0, sizeof buf
);
620 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
624 lslr
= strtoul (buf
, NULL
, 16);
625 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
& lslr
, len
);
627 return ret
== len
? 0 : EIO
;
630 /* Look up special symbols -- unneded here. */
632 spu_look_up_symbols (void)
636 /* Send signal to inferior. */
638 spu_request_interrupt (void)
640 syscall (SYS_tkill
, ptid_get_lwp (current_ptid
), SIGINT
);
643 static struct target_ops spu_target_ops
= {
655 NULL
, /* prepare_to_access_memory */
656 NULL
, /* done_accessing_memory */
660 spu_request_interrupt
,
669 hostio_last_error_from_errno
,
673 initialize_low (void)
675 static const unsigned char breakpoint
[] = { 0x00, 0x00, 0x3f, 0xff };
677 set_target_ops (&spu_target_ops
);
678 set_breakpoint_data (breakpoint
, sizeof breakpoint
);
679 init_registers_spu ();