gdb/gdbserver/spu-low.c

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