gdb/spu-linux-nat.c

   1 /* SPU native-dependent code for GDB, the GNU debugger.
   2    Copyright (C) 2006-2014 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 <string.h>
  24 #include "target.h"
  25 #include "inferior.h"
  26 #include "inf-child.h"
  27 #include "inf-ptrace.h"
  28 #include "regcache.h"
  29 #include "symfile.h"
  30 #include "gdb_wait.h"
  31 #include "gdbthread.h"
  32 #include "gdb_bfd.h"
  33
  34 #include <sys/ptrace.h>
  35 #include <asm/ptrace.h>
  36 #include <sys/types.h>
  37
  38 #include "spu-tdep.h"
  39
  40 /* PPU side system calls.  */
  41 #define INSTR_SC        0x44000002
  42 #define NR_spu_run      0x0116
  43
  44
  45 /* Fetch PPU register REGNO.  */
  46 static ULONGEST
  47 fetch_ppc_register (int regno)
  48 {
  49   PTRACE_TYPE_RET res;
  50
  51   int tid = ptid_get_lwp (inferior_ptid);
  52   if (tid == 0)
  53     tid = ptid_get_pid (inferior_ptid);
  54
  55 #ifndef __powerpc64__
  56   /* If running as a 32-bit process on a 64-bit system, we attempt
  57      to get the full 64-bit register content of the target process.
  58      If the PPC special ptrace call fails, we're on a 32-bit system;
  59      just fall through to the regular ptrace call in that case.  */
  60   {
  61     gdb_byte buf[8];
  62
  63     errno = 0;
  64     ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  65             (PTRACE_TYPE_ARG3) (regno * 8), buf);
  66     if (errno == 0)
  67       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  68               (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
  69     if (errno == 0)
  70       return (ULONGEST) *(uint64_t *)buf;
  71   }
  72 #endif
  73
  74   errno = 0;
  75   res = ptrace (PT_READ_U, tid,
  76                 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  77   if (errno != 0)
  78     {
  79       char mess[128];
  80       xsnprintf (mess, sizeof mess, "reading PPC register #%d", regno);
  81       perror_with_name (_(mess));
  82     }
  83
  84   return (ULONGEST) (unsigned long) res;
  85 }
  86
  87 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
  88 static int
  89 fetch_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET *word)
  90 {
  91   errno = 0;
  92
  93 #ifndef __powerpc64__
  94   if (memaddr >> 32)
  95     {
  96       uint64_t addr_8 = (uint64_t) memaddr;
  97       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
  98     }
  99   else
 100 #endif
 101     *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
 102
 103   return errno;
 104 }
 105
 106 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
 107 static int
 108 store_ppc_memory_1 (int tid, ULONGEST memaddr, PTRACE_TYPE_RET word)
 109 {
 110   errno = 0;
 111
 112 #ifndef __powerpc64__
 113   if (memaddr >> 32)
 114     {
 115       uint64_t addr_8 = (uint64_t) memaddr;
 116       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 117     }
 118   else
 119 #endif
 120     ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
 121
 122   return errno;
 123 }
 124
 125 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
 126 static int
 127 fetch_ppc_memory (ULONGEST memaddr, gdb_byte *myaddr, int len)
 128 {
 129   int i, ret;
 130
 131   ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 132   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 133                / sizeof (PTRACE_TYPE_RET));
 134   PTRACE_TYPE_RET *buffer;
 135
 136   int tid = ptid_get_lwp (inferior_ptid);
 137   if (tid == 0)
 138     tid = ptid_get_pid (inferior_ptid);
 139
 140   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 141   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 142     {
 143       ret = fetch_ppc_memory_1 (tid, addr, &buffer[i]);
 144       if (ret)
 145         return ret;
 146     }
 147
 148   memcpy (myaddr,
 149           (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 150           len);
 151
 152   return 0;
 153 }
 154
 155 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
 156 static int
 157 store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
 158 {
 159   int i, ret;
 160
 161   ULONGEST addr = memaddr & -(ULONGEST) sizeof (PTRACE_TYPE_RET);
 162   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 163                / sizeof (PTRACE_TYPE_RET));
 164   PTRACE_TYPE_RET *buffer;
 165
 166   int tid = ptid_get_lwp (inferior_ptid);
 167   if (tid == 0)
 168     tid = ptid_get_pid (inferior_ptid);
 169
 170   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 171
 172   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 173     {
 174       ret = fetch_ppc_memory_1 (tid, addr, &buffer[0]);
 175       if (ret)
 176         return ret;
 177     }
 178
 179   if (count > 1)
 180     {
 181       ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
 182                                                * sizeof (PTRACE_TYPE_RET),
 183                                 &buffer[count - 1]);
 184       if (ret)
 185         return ret;
 186     }
 187
 188   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 189           myaddr, len);
 190
 191   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 192     {
 193       ret = store_ppc_memory_1 (tid, addr, buffer[i]);
 194       if (ret)
 195         return ret;
 196     }
 197
 198   return 0;
 199 }
 200
 201
 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.  */
 205 static int
 206 parse_spufs_run (int *fd, ULONGEST *addr)
 207 {
 208   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 209   gdb_byte buf[4];
 210   ULONGEST pc = fetch_ppc_register (32);  /* nip */
 211
 212   /* Fetch instruction preceding current NIP.  */
 213   if (fetch_ppc_memory (pc-4, buf, 4) != 0)
 214     return 0;
 215   /* It should be a "sc" instruction.  */
 216   if (extract_unsigned_integer (buf, 4, byte_order) != INSTR_SC)
 217     return 0;
 218   /* System call number should be NR_spu_run.  */
 219   if (fetch_ppc_register (0) != NR_spu_run)
 220     return 0;
 221
 222   /* Register 3 contains fd, register 4 the NPC param pointer.  */
 223   *fd = fetch_ppc_register (34);  /* orig_gpr3 */
 224   *addr = fetch_ppc_register (4);
 225   return 1;
 226 }
 227
 228
 229 /* Implement the to_xfer_partial target_ops method for TARGET_OBJECT_SPU.
 230    Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
 231    using the /proc file system.  */
 232
 233 static enum target_xfer_status
 234 spu_proc_xfer_spu (const char *annex, gdb_byte *readbuf,
 235                    const gdb_byte *writebuf,
 236                    ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 237 {
 238   char buf[128];
 239   int fd = 0;
 240   int ret = -1;
 241   int pid = ptid_get_pid (inferior_ptid);
 242
 243   if (!annex)
 244     return TARGET_XFER_EOF;
 245
 246   xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
 247   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
 248   if (fd <= 0)
 249     return TARGET_XFER_E_IO;
 250
 251   if (offset != 0
 252       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
 253     {
 254       close (fd);
 255       return TARGET_XFER_EOF;
 256     }
 257
 258   if (writebuf)
 259     ret = write (fd, writebuf, (size_t) len);
 260   else if (readbuf)
 261     ret = read (fd, readbuf, (size_t) len);
 262
 263   close (fd);
 264   if (ret < 0)
 265     return TARGET_XFER_E_IO;
 266   else if (ret == 0)
 267     return TARGET_XFER_EOF;
 268   else
 269     {
 270       *xfered_len = (ULONGEST) ret;
 271       return TARGET_XFER_OK;
 272     }
 273 }
 274
 275
 276 /* Inferior memory should contain an SPE executable image at location ADDR.
 277    Allocate a BFD representing that executable.  Return NULL on error.  */
 278
 279 static void *
 280 spu_bfd_iovec_open (struct bfd *nbfd, void *open_closure)
 281 {
 282   return open_closure;
 283 }
 284
 285 static int
 286 spu_bfd_iovec_close (struct bfd *nbfd, void *stream)
 287 {
 288   xfree (stream);
 289
 290   /* Zero means success.  */
 291   return 0;
 292 }
 293
 294 static file_ptr
 295 spu_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
 296                      file_ptr nbytes, file_ptr offset)
 297 {
 298   ULONGEST addr = *(ULONGEST *)stream;
 299
 300   if (fetch_ppc_memory (addr + offset, buf, nbytes) != 0)
 301     {
 302       bfd_set_error (bfd_error_invalid_operation);
 303       return -1;
 304     }
 305
 306   return nbytes;
 307 }
 308
 309 static int
 310 spu_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 311 {
 312   /* We don't have an easy way of finding the size of embedded spu
 313      images.  We could parse the in-memory ELF header and section
 314      table to find the extent of the last section but that seems
 315      pointless when the size is needed only for checks of other
 316      parsed values in dbxread.c.  */
 317   sb->st_size = INT_MAX;
 318   return 0;
 319 }
 320
 321 static bfd *
 322 spu_bfd_open (ULONGEST addr)
 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,
 332                               spu_bfd_iovec_pread, spu_bfd_iovec_close,
 333                               spu_bfd_iovec_stat);
 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
 367 spu_symbol_file_add_from_memory (int inferior_fd)
 368 {
 369   ULONGEST addr;
 370   struct bfd *nbfd;
 371
 372   gdb_byte id[128];
 373   char annex[32];
 374   ULONGEST len;
 375   enum target_xfer_status status;
 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),
 394                                 SYMFILE_VERBOSE | SYMFILE_MAINLINE,
 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
 404 spu_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
 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
 423 spu_child_post_attach (struct target_ops *self, int pid)
 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))
 440     spu_symbol_file_add_from_memory (fd);
 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
 446 spu_child_wait (struct target_ops *ops,
 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
 474       clear_sigint_trap ();
 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
 495 spu_fetch_inferior_registers (struct target_ops *ops,
 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
 542 spu_store_inferior_registers (struct target_ops *ops,
 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
 578 spu_xfer_partial (struct target_ops *ops,
 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
 627 spu_can_use_hw_breakpoint (struct target_ops *self,
 628                            int type, int cnt, int othertype)
 629 {
 630   return 0;
 631 }
 632
 633 /* -Wmissing-prototypes */
 634 extern initialize_file_ftype _initialize_spu_nat;
 635
 636 /* Initialize SPU native target.  */
 637 void
 638 _initialize_spu_nat (void)
 639 {
 640   /* Generic ptrace methods.  */
 641   struct target_ops *t;
 642   t = inf_ptrace_target ();
 643
 644   /* Add SPU methods.  */
 645   t->to_post_attach = spu_child_post_attach;
 646   t->to_post_startup_inferior = spu_child_post_startup_inferior;
 647   t->to_wait = spu_child_wait;
 648   t->to_fetch_registers = spu_fetch_inferior_registers;
 649   t->to_store_registers = spu_store_inferior_registers;
 650   t->to_xfer_partial = spu_xfer_partial;
 651   t->to_can_use_hw_breakpoint = spu_can_use_hw_breakpoint;
 652
 653   /* Register SPU target.  */
 654   add_target (t);
 655 }