gdb/gdbserver/spu-low.c

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