GDB (xrefs)
/tmp/gdb-7.10/gdb/spu-linux-nat.c
Go to the documentation of this file.
1 /* SPU native-dependent code for GDB, the GNU debugger.
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 "defs.h"
22 #include "gdbcore.h"
23 #include "target.h"
24 #include "inferior.h"
25 #include "inf-child.h"
26 #include "inf-ptrace.h"
27 #include "regcache.h"
28 #include "symfile.h"
29 #include "gdb_wait.h"
30 #include "gdbthread.h"
31 #include "gdb_bfd.h"
32 
33 #include <sys/ptrace.h>
34 #include <asm/ptrace.h>
35 #include <sys/types.h>
36 
37 #include "spu-tdep.h"
38 
39 /* PPU side system calls. */
40 #define INSTR_SC 0x44000002
41 #define NR_spu_run 0x0116
42 
43 
44 /* Fetch PPU register REGNO. */
45 static ULONGEST
46 fetch_ppc_register (int regno)
47 {
48  PTRACE_TYPE_RET res;
49 
50  int tid = ptid_get_lwp (inferior_ptid);
51  if (tid == 0)
53 
54 #ifndef __powerpc64__
55  /* If running as a 32-bit process on a 64-bit system, we attempt
56  to get the full 64-bit register content of the target process.
57  If the PPC special ptrace call fails, we're on a 32-bit system;
58  just fall through to the regular ptrace call in that case. */
59  {
60  gdb_byte buf[8];
61 
62  errno = 0;
63  ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
64  (PTRACE_TYPE_ARG3) (regno * 8), buf);
65  if (errno == 0)
66  ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
67  (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
68  if (errno == 0)
69  return (ULONGEST) *(uint64_t *)buf;
70  }
71 #endif
72 
73  errno = 0;
74  res = ptrace (PT_READ_U, tid,
75  (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
76  if (errno != 0)
77  {
78  char mess[128];
79  xsnprintf (mess, sizeof mess, "reading PPC register #%d", regno);
80  perror_with_name (_(mess));
81  }
82 
83  return (ULONGEST) (unsigned long) res;
84 }
85 
86 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID. */
87 static int
89 {
90  errno = 0;
91 
92 #ifndef __powerpc64__
93  if (memaddr >> 32)
94  {
95  uint64_t addr_8 = (uint64_t) memaddr;
96  ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
97  }
98  else
99 #endif
100  *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
101 
102  return errno;
103 }
104 
105 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID. */
106 static int
108 {
109  errno = 0;
110 
111 #ifndef __powerpc64__
112  if (memaddr >> 32)
113  {
114  uint64_t addr_8 = (uint64_t) memaddr;
115  ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
116  }
117  else
118 #endif
119  ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
120 
121  return errno;
122 }
123 
124 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR. */
125 static int
126 fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
127 {
128  int i, ret;
129 
130  ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
131  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
132  / sizeof (PTRACE_TYPE_RET));
134 
135  int tid = ptid_get_lwp (inferior_ptid);
136  if (tid == 0)
137  tid = ptid_get_pid (inferior_ptid);
138 
139  buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
140  for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
141  {
142  ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
143  if (ret)
144  return ret;
145  }
146 
147  memcpy (myaddr,
148  (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
149  len);
150 
151  return 0;
152 }
153 
154 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR. */
155 static int
156 store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
157 {
158  int i, ret;
159 
160  ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
161  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
162  / sizeof (PTRACE_TYPE_RET));
164 
165  int tid = ptid_get_lwp (inferior_ptid);
166  if (tid == 0)
167  tid = ptid_get_pid (inferior_ptid);
168 
169  buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
170 
171  if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
172  {
173  ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
174  if (ret)
175  return ret;
176  }
177 
178  if (count > 1)
179  {
180  ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
181  * sizeof (PTRACE_TYPE_RET),
182  &buffer[count - 1]);
183  if (ret)
184  return ret;
185  }
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  {
192  ret = store_ppc_memory_1 (tid, addr, buffer[i]);
193  if (ret)
194  return ret;
195  }
196 
197  return 0;
198 }
199 
200 
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. */
204 static int
205 parse_spufs_run (int *fd, ULONGEST *addr)
206 {
207  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
208  gdb_byte buf[4];
209  ULONGEST pc = fetch_ppc_register (32); /* nip */
210 
211  /* Fetch instruction preceding current NIP. */
212  if (fetch_ppc_memory (pc-4, buf, 4) != 0)
213  return 0;
214  /* It should be a "sc" instruction. */
215  if (extract_unsigned_integer (buf, 4, byte_order) != INSTR_SC)
216  return 0;
217  /* System call number should be NR_spu_run. */
218  if (fetch_ppc_register (0) != NR_spu_run)
219  return 0;
220 
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);
224  return 1;
225 }
226 
227 
228 /* Implement the to_xfer_partial target_ops method for TARGET_OBJECT_SPU.
229  Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
230  using the /proc file system. */
231 
232 static enum target_xfer_status
233 spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
234  const gdb_byte *writebuf,
235  ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
236 {
237  char buf[128];
238  int fd = 0;
239  int ret = -1;
241 
242  if (!annex)
243  return TARGET_XFER_EOF;
244 
245  xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
246  fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
247  if (fd <= 0)
248  return TARGET_XFER_E_IO;
249 
250  if (offset != 0
251  && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
252  {
253  close (fd);
254  return TARGET_XFER_EOF;
255  }
256 
257  if (writebuf)
258  ret = write (fd, writebuf, (size_t) len);
259  else if (readbuf)
260  ret = read (fd, readbuf, (size_t) len);
261 
262  close (fd);
263  if (ret < 0)
264  return TARGET_XFER_E_IO;
265  else if (ret == 0)
266  return TARGET_XFER_EOF;
267  else
268  {
269  *xfered_len = (ULONGEST) ret;
270  return TARGET_XFER_OK;
271  }
272 }
273 
274 
275 /* Inferior memory should contain an SPE executable image at location ADDR.
276  Allocate a BFD representing that executable. Return NULL on error. */
277 
278 static void *
279 spu_bfd_iovec_open (struct bfd *nbfd, void *open_closure)
280 {
281  return open_closure;
282 }
283 
284 static int
285 spu_bfd_iovec_close (struct bfd *nbfd, void *stream)
286 {
287  xfree (stream);
288 
289  /* Zero means success. */
290  return 0;
291 }
292 
293 static file_ptr
294 spu_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
295  file_ptr nbytes, file_ptr offset)
296 {
297  ULONGEST addr = *(ULONGEST *)stream;
298 
299  if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
300  {
301  bfd_set_error (bfd_error_invalid_operation);
302  return -1;
303  }
304 
305  return nbytes;
306 }
307 
308 static int
309 spu_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
310 {
311  /* We don't have an easy way of finding the size of embedded spu
312  images. We could parse the in-memory ELF header and section
313  table to find the extent of the last section but that seems
314  pointless when the size is needed only for checks of other
315  parsed values in dbxread.c. */
316  memset (sb, 0, sizeof (struct stat));
317  sb->st_size = INT_MAX;
318  return 0;
319 }
320 
321 static bfd *
323 {
324  struct bfd *nbfd;
325  asection *spu_name;
326 
327  ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
328  *open_closure = addr;
329 
330  nbfd = gdb_bfd_openr_iovec ("<in-memory>", "elf32-spu",
331  spu_bfd_iovec_open, open_closure,
334  if (!nbfd)
335  return NULL;
336 
337  if (!bfd_check_format (nbfd, bfd_object))
338  {
339  gdb_bfd_unref (nbfd);
340  return NULL;
341  }
342 
343  /* Retrieve SPU name note and update BFD name. */
344  spu_name = bfd_get_section_by_name (nbfd, ".note.spu_name");
345  if (spu_name)
346  {
347  int sect_size = bfd_section_size (nbfd, spu_name);
348  if (sect_size > 20)
349  {
350  char *buf = alloca (sect_size - 20 + 1);
351  bfd_get_section_contents (nbfd, spu_name, buf, 20, sect_size - 20);
352  buf[sect_size - 20] = '\0';
353 
354  xfree ((char *)nbfd->filename);
355  nbfd->filename = xstrdup (buf);
356  }
357  }
358 
359  return nbfd;
360 }
361 
362 /* INFERIOR_FD is a file handle passed by the inferior to the
363  spu_run system call. Assuming the SPE context was allocated
364  by the libspe library, try to retrieve the main SPE executable
365  file from its copy within the target process. */
366 static void
368 {
369  ULONGEST addr;
370  struct bfd *nbfd;
371 
372  gdb_byte id[128];
373  char annex[32];
374  ULONGEST len;
376 
377  /* Read object ID. */
378  xsnprintf (annex, sizeof annex, "%d/object-id", inferior_fd);
379  status = spu_proc_xfer_spu (annex, id, NULL, 0, sizeof id, &len);
380  if (status != TARGET_XFER_OK || len >= sizeof id)
381  return;
382  id[len] = 0;
383  addr = strtoulst ((const char *) id, NULL, 16);
384  if (!addr)
385  return;
386 
387  /* Open BFD representing SPE executable and read its symbols. */
388  nbfd = spu_bfd_open (addr);
389  if (nbfd)
390  {
391  struct cleanup *cleanup = make_cleanup_bfd_unref (nbfd);
392 
393  symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd),
395  NULL, 0, NULL);
396  do_cleanups (cleanup);
397  }
398 }
399 
400 
401 /* Override the post_startup_inferior routine to continue running
402  the inferior until the first spu_run system call. */
403 static void
405 {
406  int fd;
407  ULONGEST addr;
408 
409  int tid = ptid_get_lwp (ptid);
410  if (tid == 0)
411  tid = ptid_get_pid (ptid);
412 
413  while (!parse_spufs_run (&fd, &addr))
414  {
415  ptrace (PT_SYSCALL, tid, (PTRACE_TYPE_ARG3) 0, 0);
416  waitpid (tid, NULL, __WALL | __WNOTHREAD);
417  }
418 }
419 
420 /* Override the post_attach routine to try load the SPE executable
421  file image from its copy inside the target process. */
422 static void
424 {
425  int fd;
426  ULONGEST addr;
427 
428  /* Like child_post_startup_inferior, if we happened to attach to
429  the inferior while it wasn't currently in spu_run, continue
430  running it until we get back there. */
431  while (!parse_spufs_run (&fd, &addr))
432  {
433  ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
434  waitpid (pid, NULL, __WALL | __WNOTHREAD);
435  }
436 
437  /* If the user has not provided an executable file, try to extract
438  the image from inside the target process. */
439  if (!get_exec_file (0))
441 }
442 
443 /* Wait for child PTID to do something. Return id of the child,
444  minus_one_ptid in case of error; store status into *OURSTATUS. */
445 static ptid_t
447  ptid_t ptid, struct target_waitstatus *ourstatus, int options)
448 {
449  int save_errno;
450  int status;
451  pid_t pid;
452 
453  do
454  {
455  set_sigint_trap (); /* Causes SIGINT to be passed on to the
456  attached process. */
457 
458  pid = waitpid (ptid_get_pid (ptid), &status, 0);
459  if (pid == -1 && errno == ECHILD)
460  /* Try again with __WCLONE to check cloned processes. */
461  pid = waitpid (ptid_get_pid (ptid), &status, __WCLONE);
462 
463  save_errno = errno;
464 
465  /* Make sure we don't report an event for the exit of the
466  original program, if we've detached from it. */
467  if (pid != -1 && !WIFSTOPPED (status)
468  && pid != ptid_get_pid (inferior_ptid))
469  {
470  pid = -1;
471  save_errno = EINTR;
472  }
473 
475  }
476  while (pid == -1 && save_errno == EINTR);
477 
478  if (pid == -1)
479  {
480  warning (_("Child process unexpectedly missing: %s"),
481  safe_strerror (save_errno));
482 
483  /* Claim it exited with unknown signal. */
484  ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
485  ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
486  return inferior_ptid;
487  }
488 
489  store_waitstatus (ourstatus, status);
490  return pid_to_ptid (pid);
491 }
492 
493 /* Override the fetch_inferior_register routine. */
494 static void
496  struct regcache *regcache, int regno)
497 {
498  int fd;
499  ULONGEST addr;
500 
501  /* We must be stopped on a spu_run system call. */
502  if (!parse_spufs_run (&fd, &addr))
503  return;
504 
505  /* The ID register holds the spufs file handle. */
506  if (regno == -1 || regno == SPU_ID_REGNUM)
507  {
508  struct gdbarch *gdbarch = get_regcache_arch (regcache);
509  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
510  gdb_byte buf[4];
511  store_unsigned_integer (buf, 4, byte_order, fd);
512  regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
513  }
514 
515  /* The NPC register is found at ADDR. */
516  if (regno == -1 || regno == SPU_PC_REGNUM)
517  {
518  gdb_byte buf[4];
519  if (fetch_ppc_memory (addr, buf, 4) == 0)
520  regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
521  }
522 
523  /* The GPRs are found in the "regs" spufs file. */
524  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
525  {
526  gdb_byte buf[16 * SPU_NUM_GPRS];
527  char annex[32];
528  int i;
529  ULONGEST len;
530 
531  xsnprintf (annex, sizeof annex, "%d/regs", fd);
532  if ((spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf, &len)
533  == TARGET_XFER_OK)
534  && len == sizeof buf)
535  for (i = 0; i < SPU_NUM_GPRS; i++)
536  regcache_raw_supply (regcache, i, buf + i*16);
537  }
538 }
539 
540 /* Override the store_inferior_register routine. */
541 static void
543  struct regcache *regcache, int regno)
544 {
545  int fd;
546  ULONGEST addr;
547 
548  /* We must be stopped on a spu_run system call. */
549  if (!parse_spufs_run (&fd, &addr))
550  return;
551 
552  /* The NPC register is found at ADDR. */
553  if (regno == -1 || regno == SPU_PC_REGNUM)
554  {
555  gdb_byte buf[4];
556  regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
557  store_ppc_memory (addr, buf, 4);
558  }
559 
560  /* The GPRs are found in the "regs" spufs file. */
561  if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
562  {
563  gdb_byte buf[16 * SPU_NUM_GPRS];
564  char annex[32];
565  int i;
566  ULONGEST len;
567 
568  for (i = 0; i < SPU_NUM_GPRS; i++)
569  regcache_raw_collect (regcache, i, buf + i*16);
570 
571  xsnprintf (annex, sizeof annex, "%d/regs", fd);
572  spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf, &len);
573  }
574 }
575 
576 /* Override the to_xfer_partial routine. */
577 static enum target_xfer_status
579  enum target_object object, const char *annex,
580  gdb_byte *readbuf, const gdb_byte *writebuf,
581  ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
582 {
583  if (object == TARGET_OBJECT_SPU)
584  return spu_proc_xfer_spu (annex, readbuf, writebuf, offset, len,
585  xfered_len);
586 
587  if (object == TARGET_OBJECT_MEMORY)
588  {
589  int fd;
590  ULONGEST addr;
591  char mem_annex[32], lslr_annex[32];
592  gdb_byte buf[32];
593  ULONGEST lslr;
594  enum target_xfer_status ret;
595 
596  /* We must be stopped on a spu_run system call. */
597  if (!parse_spufs_run (&fd, &addr))
598  return TARGET_XFER_EOF;
599 
600  /* Use the "mem" spufs file to access SPU local store. */
601  xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
602  ret = spu_proc_xfer_spu (mem_annex, readbuf, writebuf, offset, len,
603  xfered_len);
604  if (ret == TARGET_XFER_OK)
605  return ret;
606 
607  /* SPU local store access wraps the address around at the
608  local store limit. We emulate this here. To avoid needing
609  an extra access to retrieve the LSLR, we only do that after
610  trying the original address first, and getting end-of-file. */
611  xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
612  memset (buf, 0, sizeof buf);
613  if (spu_proc_xfer_spu (lslr_annex, buf, NULL, 0, sizeof buf, xfered_len)
614  != TARGET_XFER_OK)
615  return ret;
616 
617  lslr = strtoulst ((const char *) buf, NULL, 16);
618  return spu_proc_xfer_spu (mem_annex, readbuf, writebuf,
619  offset & lslr, len, xfered_len);
620  }
621 
622  return TARGET_XFER_E_IO;
623 }
624 
625 /* Override the to_can_use_hw_breakpoint routine. */
626 static int
628  int type, int cnt, int othertype)
629 {
630  return 0;
631 }
632 
633 /* -Wmissing-prototypes */
635 
636 /* Initialize SPU native target. */
637 void
639 {
640  /* Generic ptrace methods. */
641  struct target_ops *t;
642  t = inf_ptrace_target ();
643 
644  /* Add SPU methods. */
647  t->to_wait = spu_child_wait;
652 
653  /* Register SPU target. */
654  add_target (t);
655 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define NR_spu_run
Definition: spu-linux-nat.c:41
void add_target(struct target_ops *t)
Definition: target.c:395
ssize_t read(int fd, void *buf, size_t count)
Definition: expect-read1.c:26
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static file_ptr spu_bfd_iovec_pread(struct bfd *abfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset)
static int store_ppc_memory_1(int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
void xfree(void *)
Definition: common-utils.c:97
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
struct objfile * symbol_file_add_from_bfd(bfd *abfd, const char *name, int add_flags, struct section_addr_info *addrs, int flags, struct objfile *parent)
Definition: symfile.c:1276
static int fetch_ppc_memory(ULONGEST memaddr, gdb_byte *myaddr, int len)
#define INT_MAX
Definition: defs.h:509
void warning(const char *fmt,...)
Definition: errors.c:26
#define __WCLONE
Definition: gdb_wait.h:110
void set_sigint_trap(void)
Definition: inflow.c:795
static enum target_xfer_status spu_proc_xfer_spu(const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:468
#define _(String)
Definition: gdb_locale.h:40
struct target_ops * inf_ptrace_target(void)
Definition: inf-ptrace.c:668
#define PT_WRITE_D
Definition: gdb_ptrace.h:63
PTRACE_TYPE_RET ptrace()
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
Definition: ptid.h:35
#define PT_SYSCALL
Definition: gdb_ptrace.h:120
static void spu_symbol_file_add_from_memory(int inferior_fd)
initialize_file_ftype _initialize_spu_nat
#define PT_READ_I
Definition: gdb_ptrace.h:47
static void spu_child_post_attach(struct target_ops *self, int pid)
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
void initialize_file_ftype(void)
Definition: defs.h:281
enum gdb_signal sig
Definition: waitstatus.h:108
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:44
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
void store_waitstatus(struct target_waitstatus *ourstatus, int hoststatus)
Definition: inf-child.c:51
static int spu_bfd_iovec_stat(struct bfd *abfd, void *stream, struct stat *sb)
union target_waitstatus::@161 value
target_xfer_status
Definition: target.h:219
Definition: gdbtypes.h:749
const char * word
Definition: symtab.h:1448
#define SPU_NUM_GPRS
Definition: spu-tdep.h:25
static int store_ppc_memory(ULONGEST memaddr, const gdb_byte *myaddr, int len)
bfd * gdb_bfd_openr_iovec(const char *filename, const char *target, void *(*open_func)(struct bfd *nbfd, void *open_closure), void *open_closure, file_ptr(*pread_func)(struct bfd *nbfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset), int(*close_func)(struct bfd *nbfd, void *stream), int(*stat_func)(struct bfd *abfd, void *stream, struct stat *sb))
Definition: gdb_bfd.c:715
static void spu_fetch_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:724
ULONGEST strtoulst(const char *num, const char **trailer, int base)
Definition: common-utils.c:188
static void spu_child_post_startup_inferior(struct target_ops *self, ptid_t ptid)
static int parse_spufs_run(int *fd, ULONGEST *addr)
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
void * xmalloc(YYSIZE_T)
target_object
Definition: target.h:136
#define __WALL
Definition: linux-ptrace.h:96
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
#define PT_READ_U
Definition: gdb_ptrace.h:55
#define WIFSTOPPED(w)
Definition: gdb_wait.h:62
bfd_byte gdb_byte
Definition: common-types.h:38
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:472
static bfd * spu_bfd_open(ULONGEST addr)
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
int(* to_can_use_hw_breakpoint)(struct target_ops *, int, int, int) TARGET_DEFAULT_RETURN(0)
Definition: target.h:516
#define SEEK_SET
Definition: defs.h:87
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
static int spu_bfd_iovec_close(struct bfd *nbfd, void *stream)
enum target_waitkind kind
Definition: waitstatus.h:100
ptid_t inferior_ptid
Definition: infcmd.c:124
char * safe_strerror(int)
int offset
Definition: agent.c:65
void(* to_post_attach)(struct target_ops *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:458
Definition: buffer.h:23
static int fetch_ppc_memory_1(int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
Definition: spu-linux-nat.c:88
static void * spu_bfd_iovec_open(struct bfd *nbfd, void *open_closure)
static enum target_xfer_status spu_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
char * get_exec_file(int err)
Definition: corefile.c:179
unsigned long long ULONGEST
Definition: common-types.h:53
static void spu_store_inferior_registers(struct target_ops *ops, struct regcache *regcache, int regno)
void clear_sigint_trap(void)
Definition: inflow.c:810
long ptid_get_lwp(ptid_t ptid)
Definition: ptid.c:60
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
#define PTRACE_TYPE_ARG3
Definition: config.h:658
static ptid_t spu_child_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *ourstatus, int options)
static int spu_can_use_hw_breakpoint(struct target_ops *self, int type, int cnt, int othertype)
#define INSTR_SC
Definition: spu-linux-nat.c:40
static ULONGEST fetch_ppc_register(int regno)
Definition: spu-linux-nat.c:46
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:474
enum bfd_endian byte_order
Definition: gdbarch.c:128
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void(* to_post_startup_inferior)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:586
#define PTRACE_TYPE_RET
Definition: config.h:667
const ULONGEST const LONGEST len
Definition: target.h:309