gdb/gdbserver/spu-low.c

   1 /* Low level interface to SPUs, for the remote server for GDB.
   2    Copyright (C) 2006-2019 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 "common/gdb_wait.h"
  24 #include <sys/ptrace.h>
  25 #include <fcntl.h>
  26 #include <unistd.h>
  27 #include <sys/syscall.h>
  28 #include "common/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 = current_ptid.lwp ();
  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 = current_ptid.lwp ();
 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 = current_ptid.lwp ();
 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", current_ptid.lwp (), 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_args)
 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                        get_environ ()->envp (), 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_t (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_t (pid, pid, 0);
 323   add_thread (ptid, NULL);
 324   return 0;
 325 }
 326
 327 /* Kill the inferior process.  */
 328 static int
 329 spu_kill (process_info *process)
 330 {
 331   int status, ret;
 332   int pid = process->pid;
 333
 334   ptrace (PTRACE_KILL, pid, 0, 0);
 335
 336   do {
 337     ret = waitpid (pid, &status, 0);
 338     if (WIFEXITED (status) || WIFSIGNALED (status))
 339       break;
 340   } while (ret != -1 || errno != ECHILD);
 341
 342   clear_inferiors ();
 343   remove_process (process);
 344   return 0;
 345 }
 346
 347 /* Detach from inferior process.  */
 348 static int
 349 spu_detach (process_info *process)
 350 {
 351   ptrace (PTRACE_DETACH, process->pid, 0, 0);
 352
 353   clear_inferiors ();
 354   remove_process (process);
 355   return 0;
 356 }
 357
 358 static void
 359 spu_mourn (struct process_info *process)
 360 {
 361   remove_process (process);
 362 }
 363
 364 static void
 365 spu_join (int pid)
 366 {
 367   int status, ret;
 368
 369   do {
 370     ret = waitpid (pid, &status, 0);
 371     if (WIFEXITED (status) || WIFSIGNALED (status))
 372       break;
 373   } while (ret != -1 || errno != ECHILD);
 374 }
 375
 376 /* Return nonzero if the given thread is still alive.  */
 377 static int
 378 spu_thread_alive (ptid_t ptid)
 379 {
 380   return ptid == current_ptid;
 381 }
 382
 383 /* Resume process.  */
 384 static void
 385 spu_resume (struct thread_resume *resume_info, size_t n)
 386 {
 387   struct thread_info *thr = get_first_thread ();
 388   size_t i;
 389
 390   for (i = 0; i < n; i++)
 391     if (resume_info[i].thread == minus_one_ptid
 392         || resume_info[i].thread == ptid_of (thr))
 393       break;
 394
 395   if (i == n)
 396     return;
 397
 398   /* We don't support hardware single-stepping right now, assume
 399      GDB knows to use software single-stepping.  */
 400   if (resume_info[i].kind == resume_step)
 401     fprintf (stderr, "Hardware single-step not supported.\n");
 402
 403   regcache_invalidate ();
 404
 405   errno = 0;
 406   ptrace (PTRACE_CONT, ptid_of (thr).lwp (), 0, resume_info[i].sig);
 407   if (errno)
 408     perror_with_name ("ptrace");
 409 }
 410
 411 /* Wait for process, returns status.  */
 412 static ptid_t
 413 spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 414 {
 415   int pid = ptid.pid ();
 416   int w;
 417   int ret;
 418
 419   while (1)
 420     {
 421       ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);
 422
 423       if (ret == -1)
 424         {
 425           if (errno != ECHILD)
 426             perror_with_name ("waitpid");
 427         }
 428       else if (ret > 0)
 429         break;
 430
 431       usleep (1000);
 432     }
 433
 434   /* On the first wait, continue running the inferior until we are
 435      blocked inside an spu_run system call.  */
 436   if (!server_waiting)
 437     {
 438       int fd;
 439       CORE_ADDR addr;
 440
 441       while (!parse_spufs_run (&fd, &addr))
 442         {
 443           ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
 444           waitpid (pid, NULL, __WALL | __WNOTHREAD);
 445         }
 446     }
 447
 448   if (WIFEXITED (w))
 449     {
 450       fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
 451       ourstatus->kind =  TARGET_WAITKIND_EXITED;
 452       ourstatus->value.integer = WEXITSTATUS (w);
 453       clear_inferiors ();
 454       return ptid_t (ret);
 455     }
 456   else if (!WIFSTOPPED (w))
 457     {
 458       fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
 459       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 460       ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
 461       clear_inferiors ();
 462       return ptid_t (ret);
 463     }
 464
 465   /* After attach, we may have received a SIGSTOP.  Do not return this
 466      as signal to GDB, or else it will try to continue with SIGSTOP ...  */
 467   if (!server_waiting)
 468     {
 469       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 470       ourstatus->value.sig = GDB_SIGNAL_0;
 471       return ptid_t (ret, ret, 0);
 472     }
 473
 474   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 475   ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
 476   return ptid_t (ret, ret, 0);
 477 }
 478
 479 /* Fetch inferior registers.  */
 480 static void
 481 spu_fetch_registers (struct regcache *regcache, int regno)
 482 {
 483   int fd;
 484   CORE_ADDR addr;
 485
 486   /* We must be stopped on a spu_run system call.  */
 487   if (!parse_spufs_run (&fd, &addr))
 488     return;
 489
 490   /* The ID register holds the spufs file handle.  */
 491   if (regno == -1 || regno == SPU_ID_REGNUM)
 492     supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
 493
 494   /* The NPC register is found at ADDR.  */
 495   if (regno == -1 || regno == SPU_PC_REGNUM)
 496     {
 497       char buf[4];
 498       if (fetch_ppc_memory (addr, buf, 4) == 0)
 499         supply_register (regcache, SPU_PC_REGNUM, buf);
 500     }
 501
 502   /* The GPRs are found in the "regs" spufs file.  */
 503   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
 504     {
 505       unsigned char buf[16*SPU_NUM_CORE_REGS];
 506       char annex[32];
 507       int i;
 508
 509       sprintf (annex, "%d/regs", fd);
 510       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
 511         for (i = 0; i < SPU_NUM_CORE_REGS; i++)
 512           supply_register (regcache, i, buf + i*16);
 513     }
 514 }
 515
 516 /* Store inferior registers.  */
 517 static void
 518 spu_store_registers (struct regcache *regcache, int regno)
 519 {
 520   int fd;
 521   CORE_ADDR addr;
 522
 523   /* ??? Some callers use 0 to mean all registers.  */
 524   if (regno == 0)
 525     regno = -1;
 526
 527   /* We must be stopped on a spu_run system call.  */
 528   if (!parse_spufs_run (&fd, &addr))
 529     return;
 530
 531   /* The NPC register is found at ADDR.  */
 532   if (regno == -1 || regno == SPU_PC_REGNUM)
 533     {
 534       char buf[4];
 535       collect_register (regcache, SPU_PC_REGNUM, buf);
 536       store_ppc_memory (addr, buf, 4);
 537     }
 538
 539   /* The GPRs are found in the "regs" spufs file.  */
 540   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
 541     {
 542       unsigned char buf[16*SPU_NUM_CORE_REGS];
 543       char annex[32];
 544       int i;
 545
 546       for (i = 0; i < SPU_NUM_CORE_REGS; i++)
 547         collect_register (regcache, i, buf + i*16);
 548
 549       sprintf (annex, "%d/regs", fd);
 550       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 551     }
 552 }
 553
 554 /* Copy LEN bytes from inferior's memory starting at MEMADDR
 555    to debugger memory starting at MYADDR.  */
 556 static int
 557 spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 558 {
 559   int fd, ret;
 560   CORE_ADDR addr;
 561   char annex[32], lslr_annex[32], buf[32];
 562   CORE_ADDR lslr;
 563
 564   /* We must be stopped on a spu_run system call.  */
 565   if (!parse_spufs_run (&fd, &addr))
 566     return 0;
 567
 568   /* Use the "mem" spufs file to access SPU local store.  */
 569   sprintf (annex, "%d/mem", fd);
 570   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
 571   if (ret > 0)
 572     return ret == len ? 0 : EIO;
 573
 574   /* SPU local store access wraps the address around at the
 575      local store limit.  We emulate this here.  To avoid needing
 576      an extra access to retrieve the LSLR, we only do that after
 577      trying the original address first, and getting end-of-file.  */
 578   sprintf (lslr_annex, "%d/lslr", fd);
 579   memset (buf, 0, sizeof buf);
 580   if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
 581                          0, sizeof buf) <= 0)
 582     return ret;
 583
 584   lslr = strtoul (buf, NULL, 16);
 585   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
 586
 587   return ret == len ? 0 : EIO;
 588 }
 589
 590 /* Copy LEN bytes of data from debugger memory at MYADDR
 591    to inferior's memory at MEMADDR.
 592    On failure (cannot write the inferior)
 593    returns the value of errno.  */
 594 static int
 595 spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
 596 {
 597   int fd, ret;
 598   CORE_ADDR addr;
 599   char annex[32], lslr_annex[32], buf[32];
 600   CORE_ADDR lslr;
 601
 602   /* We must be stopped on a spu_run system call.  */
 603   if (!parse_spufs_run (&fd, &addr))
 604     return 0;
 605
 606   /* Use the "mem" spufs file to access SPU local store.  */
 607   sprintf (annex, "%d/mem", fd);
 608   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
 609   if (ret > 0)
 610     return ret == len ? 0 : EIO;
 611
 612   /* SPU local store access wraps the address around at the
 613      local store limit.  We emulate this here.  To avoid needing
 614      an extra access to retrieve the LSLR, we only do that after
 615      trying the original address first, and getting end-of-file.  */
 616   sprintf (lslr_annex, "%d/lslr", fd);
 617   memset (buf, 0, sizeof buf);
 618   if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
 619                          0, sizeof buf) <= 0)
 620     return ret;
 621
 622   lslr = strtoul (buf, NULL, 16);
 623   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
 624
 625   return ret == len ? 0 : EIO;
 626 }
 627
 628 /* Look up special symbols -- unneded here.  */
 629 static void
 630 spu_look_up_symbols (void)
 631 {
 632 }
 633
 634 /* Send signal to inferior.  */
 635 static void
 636 spu_request_interrupt (void)
 637 {
 638   struct thread_info *thr = get_first_thread ();
 639
 640   syscall (SYS_tkill, lwpid_of (thr), SIGINT);
 641 }
 642
 643 /* Implementation of the target_ops method "sw_breakpoint_from_kind".  */
 644
 645 static const gdb_byte *
 646 spu_sw_breakpoint_from_kind (int kind, int *size)
 647 {
 648   *size = sizeof breakpoint;
 649   return breakpoint;
 650 }
 651
 652 static struct target_ops spu_target_ops = {
 653   spu_create_inferior,
 654   NULL,  /* post_create_inferior */
 655   spu_attach,
 656   spu_kill,
 657   spu_detach,
 658   spu_mourn,
 659   spu_join,
 660   spu_thread_alive,
 661   spu_resume,
 662   spu_wait,
 663   spu_fetch_registers,
 664   spu_store_registers,
 665   NULL, /* prepare_to_access_memory */
 666   NULL, /* done_accessing_memory */
 667   spu_read_memory,
 668   spu_write_memory,
 669   spu_look_up_symbols,
 670   spu_request_interrupt,
 671   NULL,
 672   NULL,  /* supports_z_point_type */
 673   NULL,
 674   NULL,
 675   NULL, /* stopped_by_sw_breakpoint */
 676   NULL, /* supports_stopped_by_sw_breakpoint */
 677   NULL, /* stopped_by_hw_breakpoint */
 678   NULL, /* supports_stopped_by_hw_breakpoint */
 679   NULL, /* supports_hardware_single_step */
 680   NULL,
 681   NULL,
 682   NULL,
 683   NULL,
 684   spu_proc_xfer_spu,
 685   hostio_last_error_from_errno,
 686   NULL, /* qxfer_osdata */
 687   NULL, /* qxfer_siginfo */
 688   NULL, /* supports_non_stop */
 689   NULL, /* async */
 690   NULL, /* start_non_stop */
 691   NULL, /* supports_multi_process */
 692   NULL, /* supports_fork_events */
 693   NULL, /* supports_vfork_events */
 694   NULL, /* supports_exec_events */
 695   NULL, /* handle_new_gdb_connection */
 696   NULL, /* handle_monitor_command */
 697   NULL, /* core_of_thread */
 698   NULL, /* read_loadmap */
 699   NULL, /* process_qsupported */
 700   NULL, /* supports_tracepoints */
 701   NULL, /* read_pc */
 702   NULL, /* write_pc */
 703   NULL, /* thread_stopped */
 704   NULL, /* get_tib_address */
 705   NULL, /* pause_all */
 706   NULL, /* unpause_all */
 707   NULL, /* stabilize_threads */
 708   NULL, /* install_fast_tracepoint_jump_pad */
 709   NULL, /* emit_ops */
 710   NULL, /* supports_disable_randomization */
 711   NULL, /* get_min_fast_tracepoint_insn_len */
 712   NULL, /* qxfer_libraries_svr4 */
 713   NULL, /* support_agent */
 714   NULL, /* enable_btrace */
 715   NULL, /* disable_btrace */
 716   NULL, /* read_btrace */
 717   NULL, /* read_btrace_conf */
 718   NULL, /* supports_range_stepping */
 719   NULL, /* pid_to_exec_file */
 720   NULL, /* multifs_open */
 721   NULL, /* multifs_unlink */
 722   NULL, /* multifs_readlink */
 723   NULL, /* breakpoint_kind_from_pc */
 724   spu_sw_breakpoint_from_kind,
 725 };
 726
 727 void
 728 initialize_low (void)
 729 {
 730   set_target_ops (&spu_target_ops);
 731   init_registers_spu ();
 732 }