1 /* Low level interface to SPUs, for the remote server for GDB.
2 Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include <sys/ptrace.h>
32 #include <sys/syscall.h>
34 /* Some older glibc versions do not define this. */
36 #define __WNOTHREAD 0x20000000 /* Don't wait on children of other
37 threads in this group */
40 #define PTRACE_TYPE_RET long
41 #define PTRACE_TYPE_ARG3 long
43 /* Number of registers. */
44 #define SPU_NUM_REGS 130
45 #define SPU_NUM_CORE_REGS 128
47 /* Special registers. */
48 #define SPU_ID_REGNUM 128
49 #define SPU_PC_REGNUM 129
51 /* PPU side system calls. */
52 #define INSTR_SC 0x44000002
53 #define NR_spu_run 0x0116
55 /* Get current thread ID (Linux task ID). */
56 #define current_ptid ((struct inferior_list_entry *)current_inferior)->id
58 /* These are used in remote-utils.c. */
59 int using_threads
= 0;
61 /* Defined in auto-generated file reg-spu.c. */
62 void init_registers_spu (void);
65 /* Fetch PPU register REGNO. */
67 fetch_ppc_register (int regno
)
71 int tid
= ptid_get_lwp (current_ptid
);
74 /* If running as a 32-bit process on a 64-bit system, we attempt
75 to get the full 64-bit register content of the target process.
76 If the PPC special ptrace call fails, we're on a 32-bit system;
77 just fall through to the regular ptrace call in that case. */
82 ptrace (PPC_PTRACE_PEEKUSR_3264
, tid
,
83 (PTRACE_TYPE_ARG3
) (regno
* 8), buf
);
85 ptrace (PPC_PTRACE_PEEKUSR_3264
, tid
,
86 (PTRACE_TYPE_ARG3
) (regno
* 8 + 4), buf
+ 4);
88 return (CORE_ADDR
) *(unsigned long long *)buf
;
93 res
= ptrace (PT_READ_U
, tid
,
94 (PTRACE_TYPE_ARG3
) (regno
* sizeof (PTRACE_TYPE_RET
)), 0);
98 sprintf (mess
, "reading PPC register #%d", regno
);
99 perror_with_name (mess
);
102 return (CORE_ADDR
) (unsigned long) res
;
105 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
107 fetch_ppc_memory_1 (int tid
, CORE_ADDR memaddr
, PTRACE_TYPE_RET
*word
)
111 #ifndef __powerpc64__
114 unsigned long long addr_8
= (unsigned long long) memaddr
;
115 ptrace (PPC_PTRACE_PEEKTEXT_3264
, tid
, (PTRACE_TYPE_ARG3
) &addr_8
, word
);
119 *word
= ptrace (PT_READ_I
, tid
, (PTRACE_TYPE_ARG3
) (size_t) memaddr
, 0);
124 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
126 store_ppc_memory_1 (int tid
, CORE_ADDR memaddr
, PTRACE_TYPE_RET word
)
130 #ifndef __powerpc64__
133 unsigned long long addr_8
= (unsigned long long) memaddr
;
134 ptrace (PPC_PTRACE_POKEDATA_3264
, tid
, (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
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
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
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
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, buf
, 4) != 0)
216 /* It should be a "sc" instruction. */
217 if (*(unsigned int *)buf
!= 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
);
266 /* Start an inferior process and returns its pid.
267 ALLARGS is a vector of program-name and args. */
269 spu_create_inferior (char *program
, char **allargs
)
276 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 add_process (pid
, 0);
296 ptid
= ptid_build (pid
, pid
, 0);
297 add_thread (ptid
, NULL
);
301 /* Attach to an inferior process. */
303 spu_attach (unsigned long pid
)
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 add_process (pid
, 1);
316 ptid
= ptid_build (pid
, pid
, 0);
317 add_thread (ptid
, NULL
);
321 /* Kill the inferior process. */
326 struct process_info
*process
= find_process_pid (pid
);
330 ptrace (PTRACE_KILL
, pid
, 0, 0);
333 ret
= waitpid (pid
, &status
, 0);
334 if (WIFEXITED (status
) || WIFSIGNALED (status
))
336 } while (ret
!= -1 || errno
!= ECHILD
);
339 remove_process (process
);
343 /* Detach from inferior process. */
347 struct process_info
*process
= find_process_pid (pid
);
351 ptrace (PTRACE_DETACH
, pid
, 0, 0);
354 remove_process (process
);
359 spu_mourn (struct process_info
*process
)
361 remove_process (process
);
370 ret
= waitpid (pid
, &status
, 0);
371 if (WIFEXITED (status
) || WIFSIGNALED (status
))
373 } while (ret
!= -1 || errno
!= ECHILD
);
376 /* Return nonzero if the given thread is still alive. */
378 spu_thread_alive (ptid_t ptid
)
380 return ptid_equal (ptid
, current_ptid
);
383 /* Resume process. */
385 spu_resume (struct thread_resume
*resume_info
, size_t n
)
389 for (i
= 0; i
< n
; i
++)
390 if (ptid_equal (resume_info
[i
].thread
, minus_one_ptid
)
391 || ptid_equal (resume_info
[i
].thread
, current_ptid
))
397 /* We don't support hardware single-stepping right now, assume
398 GDB knows to use software single-stepping. */
399 if (resume_info
[i
].kind
== resume_step
)
400 fprintf (stderr
, "Hardware single-step not supported.\n");
402 regcache_invalidate ();
405 ptrace (PTRACE_CONT
, ptid_get_lwp (current_ptid
), 0, resume_info
[i
].sig
);
407 perror_with_name ("ptrace");
410 /* Wait for process, returns status. */
412 spu_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
414 int pid
= ptid_get_pid (ptid
);
420 ret
= waitpid (pid
, &w
, WNOHANG
| __WALL
| __WNOTHREAD
);
425 perror_with_name ("waitpid");
433 /* On the first wait, continue running the inferior until we are
434 blocked inside an spu_run system call. */
440 while (!parse_spufs_run (&fd
, &addr
))
442 ptrace (PT_SYSCALL
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
443 waitpid (pid
, NULL
, __WALL
| __WNOTHREAD
);
449 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
450 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
451 ourstatus
->value
.integer
= WEXITSTATUS (w
);
453 return pid_to_ptid (ret
);
455 else if (!WIFSTOPPED (w
))
457 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
458 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
459 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (w
));
461 return pid_to_ptid (ret
);
464 /* After attach, we may have received a SIGSTOP. Do not return this
465 as signal to GDB, or else it will try to continue with SIGSTOP ... */
468 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
469 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
470 return ptid_build (ret
, ret
, 0);
473 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
474 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (w
));
475 return ptid_build (ret
, ret
, 0);
478 /* Fetch inferior registers. */
480 spu_fetch_registers (struct regcache
*regcache
, int regno
)
485 /* We must be stopped on a spu_run system call. */
486 if (!parse_spufs_run (&fd
, &addr
))
489 /* The ID register holds the spufs file handle. */
490 if (regno
== -1 || regno
== SPU_ID_REGNUM
)
491 supply_register (regcache
, SPU_ID_REGNUM
, (char *)&fd
);
493 /* The NPC register is found at ADDR. */
494 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
497 if (fetch_ppc_memory (addr
, buf
, 4) == 0)
498 supply_register (regcache
, SPU_PC_REGNUM
, buf
);
501 /* The GPRs are found in the "regs" spufs file. */
502 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
504 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
508 sprintf (annex
, "%d/regs", fd
);
509 if (spu_proc_xfer_spu (annex
, buf
, NULL
, 0, sizeof buf
) == sizeof buf
)
510 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
511 supply_register (regcache
, i
, buf
+ i
*16);
515 /* Store inferior registers. */
517 spu_store_registers (struct regcache
*regcache
, int regno
)
522 /* ??? Some callers use 0 to mean all registers. */
526 /* We must be stopped on a spu_run system call. */
527 if (!parse_spufs_run (&fd
, &addr
))
530 /* The NPC register is found at ADDR. */
531 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
534 collect_register (regcache
, SPU_PC_REGNUM
, buf
);
535 store_ppc_memory (addr
, buf
, 4);
538 /* The GPRs are found in the "regs" spufs file. */
539 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
541 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
545 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
546 collect_register (regcache
, i
, buf
+ i
*16);
548 sprintf (annex
, "%d/regs", fd
);
549 spu_proc_xfer_spu (annex
, NULL
, buf
, 0, sizeof buf
);
553 /* Copy LEN bytes from inferior's memory starting at MEMADDR
554 to debugger memory starting at MYADDR. */
556 spu_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
560 char annex
[32], lslr_annex
[32], buf
[32];
563 /* We must be stopped on a spu_run system call. */
564 if (!parse_spufs_run (&fd
, &addr
))
567 /* Use the "mem" spufs file to access SPU local store. */
568 sprintf (annex
, "%d/mem", fd
);
569 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
, len
);
571 return ret
== len
? 0 : EIO
;
573 /* SPU local store access wraps the address around at the
574 local store limit. We emulate this here. To avoid needing
575 an extra access to retrieve the LSLR, we only do that after
576 trying the original address first, and getting end-of-file. */
577 sprintf (lslr_annex
, "%d/lslr", fd
);
578 memset (buf
, 0, sizeof buf
);
579 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
583 lslr
= strtoul (buf
, NULL
, 16);
584 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
& lslr
, len
);
586 return ret
== len
? 0 : EIO
;
589 /* Copy LEN bytes of data from debugger memory at MYADDR
590 to inferior's memory at MEMADDR.
591 On failure (cannot write the inferior)
592 returns the value of errno. */
594 spu_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
598 char annex
[32], lslr_annex
[32], buf
[32];
601 /* We must be stopped on a spu_run system call. */
602 if (!parse_spufs_run (&fd
, &addr
))
605 /* Use the "mem" spufs file to access SPU local store. */
606 sprintf (annex
, "%d/mem", fd
);
607 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
, len
);
609 return ret
== len
? 0 : EIO
;
611 /* SPU local store access wraps the address around at the
612 local store limit. We emulate this here. To avoid needing
613 an extra access to retrieve the LSLR, we only do that after
614 trying the original address first, and getting end-of-file. */
615 sprintf (lslr_annex
, "%d/lslr", fd
);
616 memset (buf
, 0, sizeof buf
);
617 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
621 lslr
= strtoul (buf
, NULL
, 16);
622 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
& lslr
, len
);
624 return ret
== len
? 0 : EIO
;
627 /* Look up special symbols -- unneded here. */
629 spu_look_up_symbols (void)
633 /* Send signal to inferior. */
635 spu_request_interrupt (void)
637 syscall (SYS_tkill
, ptid_get_lwp (current_ptid
), SIGINT
);
640 static struct target_ops spu_target_ops
= {
652 NULL
, /* prepare_to_access_memory */
653 NULL
, /* done_accessing_memory */
657 spu_request_interrupt
,
666 hostio_last_error_from_errno
,
670 initialize_low (void)
672 static const unsigned char breakpoint
[] = { 0x00, 0x00, 0x3f, 0xff };
674 set_target_ops (&spu_target_ops
);
675 set_breakpoint_data (breakpoint
, sizeof breakpoint
);
676 init_registers_spu ();