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>
30 #include <sys/syscall.h>
31 #include "filestuff.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 /* These are used in remote-utils.c. */
56 int using_threads
= 0;
58 /* Defined in auto-generated file reg-spu.c. */
59 void init_registers_spu (void);
60 extern const struct target_desc
*tdesc_spu
;
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 (PPC_PTRACE_PEEKUSR_3264
, tid
,
80 (PTRACE_TYPE_ARG3
) (regno
* 8), buf
);
82 ptrace (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 (PPC_PTRACE_PEEKTEXT_3264
, tid
, (PTRACE_TYPE_ARG3
) &addr_8
, word
);
116 *word
= ptrace (PT_READ_I
, tid
, (PTRACE_TYPE_ARG3
) (size_t) memaddr
, 0);
121 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
123 store_ppc_memory_1 (int tid
, CORE_ADDR memaddr
, PTRACE_TYPE_RET word
)
127 #ifndef __powerpc64__
130 unsigned long long addr_8
= (unsigned long long) memaddr
;
131 ptrace (PPC_PTRACE_POKEDATA_3264
, tid
, (PTRACE_TYPE_ARG3
) &addr_8
, word
);
135 ptrace (PT_WRITE_D
, tid
, (PTRACE_TYPE_ARG3
) (size_t) memaddr
, word
);
140 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
142 fetch_ppc_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
146 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
147 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
148 / sizeof (PTRACE_TYPE_RET
));
149 PTRACE_TYPE_RET
*buffer
;
151 int tid
= ptid_get_lwp (current_ptid
);
153 buffer
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
154 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
155 if ((ret
= fetch_ppc_memory_1 (tid
, addr
, &buffer
[i
])) != 0)
159 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
165 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
167 store_ppc_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
171 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_TYPE_RET
);
172 int count
= ((((memaddr
+ len
) - addr
) + sizeof (PTRACE_TYPE_RET
) - 1)
173 / sizeof (PTRACE_TYPE_RET
));
174 PTRACE_TYPE_RET
*buffer
;
176 int tid
= ptid_get_lwp (current_ptid
);
178 buffer
= (PTRACE_TYPE_RET
*) alloca (count
* sizeof (PTRACE_TYPE_RET
));
180 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_TYPE_RET
))
181 if ((ret
= fetch_ppc_memory_1 (tid
, addr
, &buffer
[0])) != 0)
185 if ((ret
= fetch_ppc_memory_1 (tid
, addr
+ (count
- 1)
186 * sizeof (PTRACE_TYPE_RET
),
187 &buffer
[count
- 1])) != 0)
190 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_TYPE_RET
) - 1)),
193 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_TYPE_RET
))
194 if ((ret
= store_ppc_memory_1 (tid
, addr
, buffer
[i
])) != 0)
201 /* If the PPU thread is currently stopped on a spu_run system call,
202 return to FD and ADDR the file handle and NPC parameter address
203 used with the system call. Return non-zero if successful. */
205 parse_spufs_run (int *fd
, CORE_ADDR
*addr
)
208 CORE_ADDR pc
= fetch_ppc_register (32); /* nip */
210 /* Fetch instruction preceding current NIP. */
211 if (fetch_ppc_memory (pc
-4, (char *) &insn
, 4) != 0)
213 /* It should be a "sc" instruction. */
214 if (insn
!= INSTR_SC
)
216 /* System call number should be NR_spu_run. */
217 if (fetch_ppc_register (0) != NR_spu_run
)
220 /* Register 3 contains fd, register 4 the NPC param pointer. */
221 *fd
= fetch_ppc_register (34); /* orig_gpr3 */
222 *addr
= fetch_ppc_register (4);
227 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
228 using the /proc file system. */
230 spu_proc_xfer_spu (const char *annex
, unsigned char *readbuf
,
231 const unsigned char *writebuf
,
232 CORE_ADDR offset
, int len
)
241 sprintf (buf
, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid
), annex
);
242 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
247 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
254 ret
= write (fd
, writebuf
, (size_t) len
);
256 ret
= read (fd
, readbuf
, (size_t) len
);
263 /* Start an inferior process and returns its pid.
264 ALLARGS is a vector of program-name and args. */
266 spu_create_inferior (char *program
, char **allargs
)
270 struct process_info
*proc
;
274 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 proc
= add_process (pid
, 0);
294 proc
->tdesc
= tdesc_spu
;
296 ptid
= ptid_build (pid
, pid
, 0);
297 add_thread (ptid
, NULL
);
301 /* Attach to an inferior process. */
303 spu_attach (unsigned long pid
)
306 struct process_info
*proc
;
308 if (ptrace (PTRACE_ATTACH
, pid
, 0, 0) != 0)
310 fprintf (stderr
, "Cannot attach to process %ld: %s (%d)\n", pid
,
311 strerror (errno
), errno
);
316 proc
= add_process (pid
, 1);
317 proc
->tdesc
= tdesc_spu
;
318 ptid
= ptid_build (pid
, pid
, 0);
319 add_thread (ptid
, NULL
);
323 /* Kill the inferior process. */
328 struct process_info
*process
= find_process_pid (pid
);
332 ptrace (PTRACE_KILL
, pid
, 0, 0);
335 ret
= waitpid (pid
, &status
, 0);
336 if (WIFEXITED (status
) || WIFSIGNALED (status
))
338 } while (ret
!= -1 || errno
!= ECHILD
);
341 remove_process (process
);
345 /* Detach from inferior process. */
349 struct process_info
*process
= find_process_pid (pid
);
353 ptrace (PTRACE_DETACH
, pid
, 0, 0);
356 remove_process (process
);
361 spu_mourn (struct process_info
*process
)
363 remove_process (process
);
372 ret
= waitpid (pid
, &status
, 0);
373 if (WIFEXITED (status
) || WIFSIGNALED (status
))
375 } while (ret
!= -1 || errno
!= ECHILD
);
378 /* Return nonzero if the given thread is still alive. */
380 spu_thread_alive (ptid_t ptid
)
382 return ptid_equal (ptid
, current_ptid
);
385 /* Resume process. */
387 spu_resume (struct thread_resume
*resume_info
, size_t n
)
391 for (i
= 0; i
< n
; i
++)
392 if (ptid_equal (resume_info
[i
].thread
, minus_one_ptid
)
393 || ptid_equal (resume_info
[i
].thread
, current_ptid
))
399 /* We don't support hardware single-stepping right now, assume
400 GDB knows to use software single-stepping. */
401 if (resume_info
[i
].kind
== resume_step
)
402 fprintf (stderr
, "Hardware single-step not supported.\n");
404 regcache_invalidate ();
407 ptrace (PTRACE_CONT
, ptid_get_lwp (current_ptid
), 0, resume_info
[i
].sig
);
409 perror_with_name ("ptrace");
412 /* Wait for process, returns status. */
414 spu_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
416 int pid
= ptid_get_pid (ptid
);
422 ret
= waitpid (pid
, &w
, WNOHANG
| __WALL
| __WNOTHREAD
);
427 perror_with_name ("waitpid");
435 /* On the first wait, continue running the inferior until we are
436 blocked inside an spu_run system call. */
442 while (!parse_spufs_run (&fd
, &addr
))
444 ptrace (PT_SYSCALL
, pid
, (PTRACE_TYPE_ARG3
) 0, 0);
445 waitpid (pid
, NULL
, __WALL
| __WNOTHREAD
);
451 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
452 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
453 ourstatus
->value
.integer
= WEXITSTATUS (w
);
455 return pid_to_ptid (ret
);
457 else if (!WIFSTOPPED (w
))
459 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
460 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
461 ourstatus
->value
.sig
= gdb_signal_from_host (WTERMSIG (w
));
463 return pid_to_ptid (ret
);
466 /* After attach, we may have received a SIGSTOP. Do not return this
467 as signal to GDB, or else it will try to continue with SIGSTOP ... */
470 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
471 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
472 return ptid_build (ret
, ret
, 0);
475 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
476 ourstatus
->value
.sig
= gdb_signal_from_host (WSTOPSIG (w
));
477 return ptid_build (ret
, ret
, 0);
480 /* Fetch inferior registers. */
482 spu_fetch_registers (struct regcache
*regcache
, int regno
)
487 /* We must be stopped on a spu_run system call. */
488 if (!parse_spufs_run (&fd
, &addr
))
491 /* The ID register holds the spufs file handle. */
492 if (regno
== -1 || regno
== SPU_ID_REGNUM
)
493 supply_register (regcache
, SPU_ID_REGNUM
, (char *)&fd
);
495 /* The NPC register is found at ADDR. */
496 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
499 if (fetch_ppc_memory (addr
, buf
, 4) == 0)
500 supply_register (regcache
, SPU_PC_REGNUM
, buf
);
503 /* The GPRs are found in the "regs" spufs file. */
504 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
506 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
510 sprintf (annex
, "%d/regs", fd
);
511 if (spu_proc_xfer_spu (annex
, buf
, NULL
, 0, sizeof buf
) == sizeof buf
)
512 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
513 supply_register (regcache
, i
, buf
+ i
*16);
517 /* Store inferior registers. */
519 spu_store_registers (struct regcache
*regcache
, int regno
)
524 /* ??? Some callers use 0 to mean all registers. */
528 /* We must be stopped on a spu_run system call. */
529 if (!parse_spufs_run (&fd
, &addr
))
532 /* The NPC register is found at ADDR. */
533 if (regno
== -1 || regno
== SPU_PC_REGNUM
)
536 collect_register (regcache
, SPU_PC_REGNUM
, buf
);
537 store_ppc_memory (addr
, buf
, 4);
540 /* The GPRs are found in the "regs" spufs file. */
541 if (regno
== -1 || (regno
>= 0 && regno
< SPU_NUM_CORE_REGS
))
543 unsigned char buf
[16*SPU_NUM_CORE_REGS
];
547 for (i
= 0; i
< SPU_NUM_CORE_REGS
; i
++)
548 collect_register (regcache
, i
, buf
+ i
*16);
550 sprintf (annex
, "%d/regs", fd
);
551 spu_proc_xfer_spu (annex
, NULL
, buf
, 0, sizeof buf
);
555 /* Copy LEN bytes from inferior's memory starting at MEMADDR
556 to debugger memory starting at MYADDR. */
558 spu_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
562 char annex
[32], lslr_annex
[32], buf
[32];
565 /* We must be stopped on a spu_run system call. */
566 if (!parse_spufs_run (&fd
, &addr
))
569 /* Use the "mem" spufs file to access SPU local store. */
570 sprintf (annex
, "%d/mem", fd
);
571 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
, len
);
573 return ret
== len
? 0 : EIO
;
575 /* SPU local store access wraps the address around at the
576 local store limit. We emulate this here. To avoid needing
577 an extra access to retrieve the LSLR, we only do that after
578 trying the original address first, and getting end-of-file. */
579 sprintf (lslr_annex
, "%d/lslr", fd
);
580 memset (buf
, 0, sizeof buf
);
581 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
585 lslr
= strtoul (buf
, NULL
, 16);
586 ret
= spu_proc_xfer_spu (annex
, myaddr
, NULL
, memaddr
& lslr
, len
);
588 return ret
== len
? 0 : EIO
;
591 /* Copy LEN bytes of data from debugger memory at MYADDR
592 to inferior's memory at MEMADDR.
593 On failure (cannot write the inferior)
594 returns the value of errno. */
596 spu_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
600 char annex
[32], lslr_annex
[32], buf
[32];
603 /* We must be stopped on a spu_run system call. */
604 if (!parse_spufs_run (&fd
, &addr
))
607 /* Use the "mem" spufs file to access SPU local store. */
608 sprintf (annex
, "%d/mem", fd
);
609 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
, len
);
611 return ret
== len
? 0 : EIO
;
613 /* SPU local store access wraps the address around at the
614 local store limit. We emulate this here. To avoid needing
615 an extra access to retrieve the LSLR, we only do that after
616 trying the original address first, and getting end-of-file. */
617 sprintf (lslr_annex
, "%d/lslr", fd
);
618 memset (buf
, 0, sizeof buf
);
619 if (spu_proc_xfer_spu (lslr_annex
, (unsigned char *)buf
, NULL
,
623 lslr
= strtoul (buf
, NULL
, 16);
624 ret
= spu_proc_xfer_spu (annex
, NULL
, myaddr
, memaddr
& lslr
, len
);
626 return ret
== len
? 0 : EIO
;
629 /* Look up special symbols -- unneded here. */
631 spu_look_up_symbols (void)
635 /* Send signal to inferior. */
637 spu_request_interrupt (void)
639 syscall (SYS_tkill
, ptid_get_lwp (current_ptid
), SIGINT
);
642 static struct target_ops spu_target_ops
= {
654 NULL
, /* prepare_to_access_memory */
655 NULL
, /* done_accessing_memory */
659 spu_request_interrupt
,
661 NULL
, /* supports_z_point_type */
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 ();