GDBserver
spu-low.c
Go to the documentation of this file.
1 /* Low level interface to SPUs, for the remote server for GDB.
2  Copyright (C) 2006-2015 Free Software Foundation, Inc.
3 
4  Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
5 
6  This file is part of GDB.
7 
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.
12 
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.
17 
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/>. */
20 
21 #include "server.h"
22 
23 #include "gdb_wait.h"
24 #include <sys/ptrace.h>
25 #include <fcntl.h>
26 #include <unistd.h>
27 #include <sys/syscall.h>
28 #include "filestuff.h"
29 #include "hostio.h"
30 
31 /* Some older glibc versions do not define this. */
32 #ifndef __WNOTHREAD
33 #define __WNOTHREAD 0x20000000 /* Don't wait on children of other
34  threads in this group */
35 #endif
36 
37 #define PTRACE_TYPE_RET long
38 #define PTRACE_TYPE_ARG3 long
39 
40 /* Number of registers. */
41 #define SPU_NUM_REGS 130
42 #define SPU_NUM_CORE_REGS 128
43 
44 /* Special registers. */
45 #define SPU_ID_REGNUM 128
46 #define SPU_PC_REGNUM 129
47 
48 /* PPU side system calls. */
49 #define INSTR_SC 0x44000002
50 #define NR_spu_run 0x0116
51 
52 /* These are used in remote-utils.c. */
53 int using_threads = 0;
54 
55 /* Defined in auto-generated file reg-spu.c. */
56 void init_registers_spu (void);
57 extern const struct target_desc *tdesc_spu;
58 
59 /* Fetch PPU register REGNO. */
60 static CORE_ADDR
61 fetch_ppc_register (int regno)
62 {
63  PTRACE_TYPE_RET res;
64 
65  int tid = ptid_get_lwp (current_ptid);
66 
67 #ifndef __powerpc64__
68  /* If running as a 32-bit process on a 64-bit system, we attempt
69  to get the full 64-bit register content of the target process.
70  If the PPC special ptrace call fails, we're on a 32-bit system;
71  just fall through to the regular ptrace call in that case. */
72  {
73  char buf[8];
74 
75  errno = 0;
76  ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
77  (PTRACE_TYPE_ARG3) (regno * 8), buf);
78  if (errno == 0)
79  ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
80  (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
81  if (errno == 0)
82  return (CORE_ADDR) *(unsigned long long *)buf;
83  }
84 #endif
85 
86  errno = 0;
87  res = ptrace (PT_READ_U, tid,
88  (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
89  if (errno != 0)
90  {
91  char mess[128];
92  sprintf (mess, "reading PPC register #%d", regno);
93  perror_with_name (mess);
94  }
95 
96  return (CORE_ADDR) (unsigned long) res;
97 }
98 
99 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
100 static int
102 {
103  errno = 0;
104 
105 #ifndef __powerpc64__
106  if (memaddr >> 32)
107  {
108  unsigned long long addr_8 = (unsigned long long) memaddr;
109  ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
110  }
111  else
112 #endif
113  *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
114 
115  return errno;
116 }
117 
118 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
119 static int
121 {
122  errno = 0;
123 
124 #ifndef __powerpc64__
125  if (memaddr >> 32)
126  {
127  unsigned long long addr_8 = (unsigned long long) memaddr;
128  ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
129  }
130  else
131 #endif
132  ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
133 
134  return errno;
135 }
136 
137 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
138 static int
139 fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
140 {
141  int i, ret;
142 
143  CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
144  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
145  / sizeof (PTRACE_TYPE_RET));
147 
148  int tid = ptid_get_lwp (current_ptid);
149 
150  buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
151  for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
152  if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
153  return ret;
154 
155  memcpy (myaddr,
156  (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
157  len);
158 
159  return 0;
160 }
161 
162 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
163 static int
164 store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
165 {
166  int i, ret;
167 
168  CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
169  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
170  / sizeof (PTRACE_TYPE_RET));
172 
173  int tid = ptid_get_lwp (current_ptid);
174 
175  buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
176 
177  if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
178  if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
179  return ret;
180 
181  if (count > 1)
182  if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
183  * sizeof (PTRACE_TYPE_RET),
184  &buffer[count - 1])) != 0)
185  return ret;
186 
187  memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
188  myaddr, len);
189 
190  for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
191  if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
192  return ret;
193 
194  return 0;
195 }
196 
197 
198 /* If the PPU thread is currently stopped on a spu_run system call,
199  return to FD and ADDR the file handle and NPC parameter address
200  used with the system call. Return non-zero if successful. */
201 static int
202 parse_spufs_run (int *fd, CORE_ADDR *addr)
203 {
204  unsigned int insn;
205  CORE_ADDR pc = fetch_ppc_register (32); /* nip */
206 
207  /* Fetch instruction preceding current NIP. */
208  if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
209  return 0;
210  /* It should be a "sc" instruction. */
211  if (insn != INSTR_SC)
212  return 0;
213  /* System call number should be NR_spu_run. */
214  if (fetch_ppc_register (0) != NR_spu_run)
215  return 0;
216 
217  /* Register 3 contains fd, register 4 the NPC param pointer. */
218  *fd = fetch_ppc_register (34); /* orig_gpr3 */
219  *addr = fetch_ppc_register (4);
220  return 1;
221 }
222 
223 
224 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
225  using the /proc file system. */
226 static int
227 spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
228  const unsigned char *writebuf,
229  CORE_ADDR offset, int len)
230 {
231  char buf[128];
232  int fd = 0;
233  int ret = -1;
234 
235  if (!annex)
236  return 0;
237 
238  sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
239  fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
240  if (fd <= 0)
241  return -1;
242 
243  if (offset != 0
244  && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
245  {
246  close (fd);
247  return 0;
248  }
249 
250  if (writebuf)
251  ret = write (fd, writebuf, (size_t) len);
252  else if (readbuf)
253  ret = read (fd, readbuf, (size_t) len);
254 
255  close (fd);
256  return ret;
257 }
258 
259 
260 /* Start an inferior process and returns its pid.
261  ALLARGS is a vector of program-name and args. */
262 static int
263 spu_create_inferior (char *program, char **allargs)
264 {
265  int pid;
266  ptid_t ptid;
267  struct process_info *proc;
268 
269  pid = fork ();
270  if (pid < 0)
271  perror_with_name ("fork");
272 
273  if (pid == 0)
274  {
275  close_most_fds ();
276  ptrace (PTRACE_TRACEME, 0, 0, 0);
277 
278  setpgid (0, 0);
279 
280  execv (program, allargs);
281  if (errno == ENOENT)
282  execvp (program, allargs);
283 
284  fprintf (stderr, "Cannot exec %s: %s.\n", program,
285  strerror (errno));
286  fflush (stderr);
287  _exit (0177);
288  }
289 
290  proc = add_process (pid, 0);
291  proc->tdesc = tdesc_spu;
292 
293  ptid = ptid_build (pid, pid, 0);
294  add_thread (ptid, NULL);
295  return pid;
296 }
297 
298 /* Attach to an inferior process. */
299 int
300 spu_attach (unsigned long pid)
301 {
302  ptid_t ptid;
303  struct process_info *proc;
304 
305  if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
306  {
307  fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
308  strerror (errno), errno);
309  fflush (stderr);
310  _exit (0177);
311  }
312 
313  proc = add_process (pid, 1);
314  proc->tdesc = tdesc_spu;
315  ptid = ptid_build (pid, pid, 0);
316  add_thread (ptid, NULL);
317  return 0;
318 }
319 
320 /* Kill the inferior process. */
321 static int
322 spu_kill (int pid)
323 {
324  int status, ret;
325  struct process_info *process = find_process_pid (pid);
326  if (process == NULL)
327  return -1;
328 
329  ptrace (PTRACE_KILL, pid, 0, 0);
330 
331  do {
332  ret = waitpid (pid, &status, 0);
333  if (WIFEXITED (status) || WIFSIGNALED (status))
334  break;
335  } while (ret != -1 || errno != ECHILD);
336 
337  clear_inferiors ();
338  remove_process (process);
339  return 0;
340 }
341 
342 /* Detach from inferior process. */
343 static int
344 spu_detach (int pid)
345 {
346  struct process_info *process = find_process_pid (pid);
347  if (process == NULL)
348  return -1;
349 
350  ptrace (PTRACE_DETACH, pid, 0, 0);
351 
352  clear_inferiors ();
353  remove_process (process);
354  return 0;
355 }
356 
357 static void
358 spu_mourn (struct process_info *process)
359 {
360  remove_process (process);
361 }
362 
363 static void
364 spu_join (int pid)
365 {
366  int status, ret;
367 
368  do {
369  ret = waitpid (pid, &status, 0);
370  if (WIFEXITED (status) || WIFSIGNALED (status))
371  break;
372  } while (ret != -1 || errno != ECHILD);
373 }
374 
375 /* Return nonzero if the given thread is still alive. */
376 static int
378 {
379  return ptid_equal (ptid, current_ptid);
380 }
381 
382 /* Resume process. */
383 static void
384 spu_resume (struct thread_resume *resume_info, size_t n)
385 {
386  size_t i;
387 
388  for (i = 0; i < n; i++)
389  if (ptid_equal (resume_info[i].thread, minus_one_ptid)
390  || ptid_equal (resume_info[i].thread, current_ptid))
391  break;
392 
393  if (i == n)
394  return;
395 
396  /* We don't support hardware single-stepping right now, assume
397  GDB knows to use software single-stepping. */
398  if (resume_info[i].kind == resume_step)
399  fprintf (stderr, "Hardware single-step not supported.\n");
400 
402 
403  errno = 0;
404  ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig);
405  if (errno)
406  perror_with_name ("ptrace");
407 }
408 
409 /* Wait for process, returns status. */
410 static ptid_t
411 spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
412 {
413  int pid = ptid_get_pid (ptid);
414  int w;
415  int ret;
416 
417  while (1)
418  {
419  ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);
420 
421  if (ret == -1)
422  {
423  if (errno != ECHILD)
424  perror_with_name ("waitpid");
425  }
426  else if (ret > 0)
427  break;
428 
429  usleep (1000);
430  }
431 
432  /* On the first wait, continue running the inferior until we are
433  blocked inside an spu_run system call. */
434  if (!server_waiting)
435  {
436  int fd;
437  CORE_ADDR addr;
438 
439  while (!parse_spufs_run (&fd, &addr))
440  {
441  ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
442  waitpid (pid, NULL, __WALL | __WNOTHREAD);
443  }
444  }
445 
446  if (WIFEXITED (w))
447  {
448  fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
449  ourstatus->kind = TARGET_WAITKIND_EXITED;
450  ourstatus->value.integer = WEXITSTATUS (w);
451  clear_inferiors ();
452  return pid_to_ptid (ret);
453  }
454  else if (!WIFSTOPPED (w))
455  {
456  fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
457  ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
458  ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
459  clear_inferiors ();
460  return pid_to_ptid (ret);
461  }
462 
463  /* After attach, we may have received a SIGSTOP. Do not return this
464  as signal to GDB, or else it will try to continue with SIGSTOP ... */
465  if (!server_waiting)
466  {
467  ourstatus->kind = TARGET_WAITKIND_STOPPED;
468  ourstatus->value.sig = GDB_SIGNAL_0;
469  return ptid_build (ret, ret, 0);
470  }
471 
472  ourstatus->kind = TARGET_WAITKIND_STOPPED;
473  ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
474  return ptid_build (ret, ret, 0);
475 }
476 
477 /* Fetch inferior registers. */
478 static void
480 {
481  int fd;
482  CORE_ADDR addr;
483 
484  /* We must be stopped on a spu_run system call. */
485  if (!parse_spufs_run (&fd, &addr))
486  return;
487 
488  /* The ID register holds the spufs file handle. */
489  if (regno == -1 || regno == SPU_ID_REGNUM)
490  supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
491 
492  /* The NPC register is found at ADDR. */
493  if (regno == -1 || regno == SPU_PC_REGNUM)
494  {
495  char buf[4];
496  if (fetch_ppc_memory (addr, buf, 4) == 0)
497  supply_register (regcache, SPU_PC_REGNUM, buf);
498  }
499 
500  /* The GPRs are found in the "regs" spufs file. */
501  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
502  {
503  unsigned char buf[16*SPU_NUM_CORE_REGS];
504  char annex[32];
505  int i;
506 
507  sprintf (annex, "%d/regs", fd);
508  if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
509  for (i = 0; i < SPU_NUM_CORE_REGS; i++)
510  supply_register (regcache, i, buf + i*16);
511  }
512 }
513 
514 /* Store inferior registers. */
515 static void
517 {
518  int fd;
519  CORE_ADDR addr;
520 
521  /* ??? Some callers use 0 to mean all registers. */
522  if (regno == 0)
523  regno = -1;
524 
525  /* We must be stopped on a spu_run system call. */
526  if (!parse_spufs_run (&fd, &addr))
527  return;
528 
529  /* The NPC register is found at ADDR. */
530  if (regno == -1 || regno == SPU_PC_REGNUM)
531  {
532  char buf[4];
533  collect_register (regcache, SPU_PC_REGNUM, buf);
534  store_ppc_memory (addr, buf, 4);
535  }
536 
537  /* The GPRs are found in the "regs" spufs file. */
538  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
539  {
540  unsigned char buf[16*SPU_NUM_CORE_REGS];
541  char annex[32];
542  int i;
543 
544  for (i = 0; i < SPU_NUM_CORE_REGS; i++)
545  collect_register (regcache, i, buf + i*16);
546 
547  sprintf (annex, "%d/regs", fd);
548  spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
549  }
550 }
551 
552 /* Copy LEN bytes from inferior's memory starting at MEMADDR
553  to debugger memory starting at MYADDR. */
554 static int
555 spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
556 {
557  int fd, ret;
558  CORE_ADDR addr;
559  char annex[32], lslr_annex[32], buf[32];
560  CORE_ADDR lslr;
561 
562  /* We must be stopped on a spu_run system call. */
563  if (!parse_spufs_run (&fd, &addr))
564  return 0;
565 
566  /* Use the "mem" spufs file to access SPU local store. */
567  sprintf (annex, "%d/mem", fd);
568  ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
569  if (ret > 0)
570  return ret == len ? 0 : EIO;
571 
572  /* SPU local store access wraps the address around at the
573  local store limit. We emulate this here. To avoid needing
574  an extra access to retrieve the LSLR, we only do that after
575  trying the original address first, and getting end-of-file. */
576  sprintf (lslr_annex, "%d/lslr", fd);
577  memset (buf, 0, sizeof buf);
578  if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
579  0, sizeof buf) <= 0)
580  return ret;
581 
582  lslr = strtoul (buf, NULL, 16);
583  ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
584 
585  return ret == len ? 0 : EIO;
586 }
587 
588 /* Copy LEN bytes of data from debugger memory at MYADDR
589  to inferior's memory at MEMADDR.
590  On failure (cannot write the inferior)
591  returns the value of errno. */
592 static int
593 spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
594 {
595  int fd, ret;
596  CORE_ADDR addr;
597  char annex[32], lslr_annex[32], buf[32];
598  CORE_ADDR lslr;
599 
600  /* We must be stopped on a spu_run system call. */
601  if (!parse_spufs_run (&fd, &addr))
602  return 0;
603 
604  /* Use the "mem" spufs file to access SPU local store. */
605  sprintf (annex, "%d/mem", fd);
606  ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
607  if (ret > 0)
608  return ret == len ? 0 : EIO;
609 
610  /* SPU local store access wraps the address around at the
611  local store limit. We emulate this here. To avoid needing
612  an extra access to retrieve the LSLR, we only do that after
613  trying the original address first, and getting end-of-file. */
614  sprintf (lslr_annex, "%d/lslr", fd);
615  memset (buf, 0, sizeof buf);
616  if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
617  0, sizeof buf) <= 0)
618  return ret;
619 
620  lslr = strtoul (buf, NULL, 16);
621  ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
622 
623  return ret == len ? 0 : EIO;
624 }
625 
626 /* Look up special symbols -- unneded here. */
627 static void
629 {
630 }
631 
632 /* Send signal to inferior. */
633 static void
635 {
636  syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);
637 }
638 
639 static struct target_ops spu_target_ops = {
641  spu_attach,
642  spu_kill,
643  spu_detach,
644  spu_mourn,
645  spu_join,
647  spu_resume,
648  spu_wait,
651  NULL, /* prepare_to_access_memory */
652  NULL, /* done_accessing_memory */
657  NULL,
658  NULL, /* supports_z_point_type */
659  NULL,
660  NULL,
661  NULL, /* stopped_by_sw_breakpoint */
662  NULL, /* supports_stopped_by_sw_breakpoint */
663  NULL, /* stopped_by_hw_breakpoint */
664  NULL, /* supports_stopped_by_hw_breakpoint */
665  NULL, /* supports_conditional_breakpoints */
666  NULL,
667  NULL,
668  NULL,
669  NULL,
672 };
673 
674 void
676 {
677  static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
678 
679  set_target_ops (&spu_target_ops);
680  set_breakpoint_data (breakpoint, sizeof breakpoint);
682 }
static void spu_request_interrupt(void)
Definition: spu-low.c:634
void collect_register(struct regcache *regcache, int n, void *buf)
Definition: regcache.c:414
int using_threads
Definition: spu-low.c:53
static void spu_store_registers(struct regcache *regcache, int regno)
Definition: spu-low.c:516
struct process_info * add_process(int pid, int attached)
Definition: inferiors.c:274
#define WNOHANG
Definition: gdb_wait.h:102
static void spu_resume(struct thread_resume *resume_info, size_t n)
Definition: spu-low.c:384
static void spu_look_up_symbols(void)
Definition: spu-low.c:628
static int store_ppc_memory(CORE_ADDR memaddr, char *myaddr, int len)
Definition: spu-low.c:164
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define SPU_PC_REGNUM
Definition: spu-low.c:46
static int spu_kill(int pid)
Definition: spu-low.c:322
int server_waiting
Definition: server.c:50
struct process_info * find_process_pid(int pid)
Definition: inferiors.c:302
void set_breakpoint_data(const unsigned char *bp_data, int bp_len)
Definition: mem-break.c:1592
static int fetch_ppc_memory(CORE_ADDR memaddr, char *myaddr, int len)
Definition: spu-low.c:139
static int spu_proc_xfer_spu(const char *annex, unsigned char *readbuf, const unsigned char *writebuf, CORE_ADDR offset, int len)
Definition: spu-low.c:227
const struct target_desc * tdesc
Definition: inferiors.h:69
#define NR_spu_run
Definition: spu-low.c:50
Definition: ptid.h:35
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
#define WSTOPSIG
Definition: gdb_wait.h:75
static int store_ppc_memory_1(int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
Definition: spu-low.c:120
static int spu_create_inferior(char *program, char **allargs)
Definition: spu-low.c:263
const struct target_desc * tdesc_spu
#define WTERMSIG(w)
Definition: gdb_wait.h:71
void regcache_invalidate(void)
Definition: regcache.c:111
#define WIFEXITED(w)
Definition: gdb_wait.h:44
int offset
Definition: tracepoint.c:179
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:44
#define current_ptid
Definition: gdbthread.h:83
enum gdb_signal gdb_signal_from_host(int)
Definition: signals.c:116
static int spu_thread_alive(ptid_t ptid)
Definition: spu-low.c:377
static CORE_ADDR fetch_ppc_register(int regno)
Definition: spu-low.c:61
#define PTRACE_TYPE_ARG3
Definition: spu-low.c:38
void remove_process(struct process_info *process)
Definition: inferiors.c:293
void set_target_ops(struct target_ops *target)
Definition: target.c:184
static int spu_detach(int pid)
Definition: spu-low.c:344
#define WEXITSTATUS(w)
Definition: gdb_wait.h:67
#define INSTR_SC
Definition: spu-low.c:49
#define __WNOTHREAD
Definition: spu-low.c:33
void close_most_fds(void)
Definition: filestuff.c:224
#define __WALL
Definition: linux-ptrace.h:96
#define errno
Definition: wincecompat.h:24
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
#define WIFSTOPPED(w)
Definition: gdb_wait.h:62
#define SPU_ID_REGNUM
Definition: spu-low.c:45
static int spu_write_memory(CORE_ADDR memaddr, const unsigned char *myaddr, int len)
Definition: spu-low.c:593
void * alloca(size_t)
static ptid_t spu_wait(ptid_t ptid, struct target_waitstatus *ourstatus, int options)
Definition: spu-low.c:411
Definition: buffer.h:23
void hostio_last_error_from_errno(char *buf)
Definition: hostio-errno.c:28
static int fetch_ppc_memory_1(int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
Definition: spu-low.c:101
void perror_with_name(const char *string)
Definition: utils.c:57
static void spu_fetch_registers(struct regcache *regcache, int regno)
Definition: spu-low.c:479
int spu_attach(unsigned long pid)
Definition: spu-low.c:300
#define WIFSIGNALED(w)
Definition: gdb_wait.h:48
long ptid_get_lwp(ptid_t ptid)
Definition: ptid.c:60
void init_registers_spu(void)
static void spu_join(int pid)
Definition: spu-low.c:364
void initialize_low(void)
Definition: spu-low.c:675
static void spu_mourn(struct process_info *process)
Definition: spu-low.c:358
static int parse_spufs_run(int *fd, CORE_ADDR *addr)
Definition: spu-low.c:202
#define SPU_NUM_CORE_REGS
Definition: spu-low.c:42
void supply_register(struct regcache *regcache, int n, const void *buf)
Definition: regcache.c:330
struct thread_info * add_thread(ptid_t ptid, void *target_data)
Definition: inferiors.c:106
static int spu_read_memory(CORE_ADDR memaddr, unsigned char *myaddr, int len)
Definition: spu-low.c:555
void clear_inferiors(void)
Definition: inferiors.c:263
ptid_t minus_one_ptid
Definition: ptid.c:26
#define PTRACE_TYPE_RET
Definition: spu-low.c:37
char * strerror(int)