gdb/gdbserver/spu-low.c

   1 /* Low level interface to SPUs, for the remote server for GDB.
   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 "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
  31 /* Some older glibc versions do not define this.  */
  32 #ifndef __WNOTHREAD
  33 #define __WNOTHREAD     0x20000000      /* Don't wait on children of other
  34                                            threads in this group */
  35 #endif
  36
  37 #define PTRACE_TYPE_RET long
  38 #define PTRACE_TYPE_ARG3 long
  39
  40 /* Number of registers.  */
  41 #define SPU_NUM_REGS         130
  42 #define SPU_NUM_CORE_REGS    128
  43
  44 /* Special registers.  */
  45 #define SPU_ID_REGNUM        128
  46 #define SPU_PC_REGNUM        129
  47
  48 /* PPU side system calls.  */
  49 #define INSTR_SC        0x44000002
  50 #define NR_spu_run      0x0116
  51
  52 /* These are used in remote-utils.c.  */
  53 int using_threads = 0;
  54
  55 /* Defined in auto-generated file reg-spu.c.  */
  56 void init_registers_spu (void);
  57 extern const struct target_desc *tdesc_spu;
  58
  59 /* Software breakpoint instruction.  */
  60 static const gdb_byte breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
  61
  62 /* Fetch PPU register REGNO.  */
  63 static CORE_ADDR
  64 fetch_ppc_register (int regno)
  65 {
  66   PTRACE_TYPE_RET res;
  67
  68   int tid = ptid_get_lwp (current_ptid);
  69
  70 #ifndef __powerpc64__
  71   /* If running as a 32-bit process on a 64-bit system, we attempt
  72      to get the full 64-bit register content of the target process.
  73      If the PPC special ptrace call fails, we're on a 32-bit system;
  74      just fall through to the regular ptrace call in that case.  */
  75   {
  76     char buf[8];
  77
  78     errno = 0;
  79     ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  80             (PTRACE_TYPE_ARG3) (regno * 8), buf);
  81     if (errno == 0)
  82       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  83               (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
  84     if (errno == 0)
  85       return (CORE_ADDR) *(unsigned long long *)buf;
  86   }
  87 #endif
  88
  89   errno = 0;
  90   res = ptrace (PT_READ_U, tid,
  91                 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  92   if (errno != 0)
  93     {
  94       char mess[128];
  95       sprintf (mess, "reading PPC register #%d", regno);
  96       perror_with_name (mess);
  97     }
  98
  99   return (CORE_ADDR) (unsigned long) res;
 100 }
 101
 102 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
 103 static int
 104 fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
 105 {
 106   errno = 0;
 107
 108 #ifndef __powerpc64__
 109   if (memaddr >> 32)
 110     {
 111       unsigned long long addr_8 = (unsigned long long) memaddr;
 112       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 113     }
 114   else
 115 #endif
 116     *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
 117
 118   return errno;
 119 }
 120
 121 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
 122 static int
 123 store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
 124 {
 125   errno = 0;
 126
 127 #ifndef __powerpc64__
 128   if (memaddr >> 32)
 129     {
 130       unsigned long long addr_8 = (unsigned long long) memaddr;
 131       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 132     }
 133   else
 134 #endif
 135     ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
 136
 137   return errno;
 138 }
 139
 140 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
 141 static int
 142 fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 143 {
 144   int i, ret;
 145
 146   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 147   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 148                / sizeof (PTRACE_TYPE_RET));
 149   PTRACE_TYPE_RET *buffer;
 150
 151   int tid = ptid_get_lwp (current_ptid);
 152
 153   buffer = XALLOCAVEC (PTRACE_TYPE_RET, count);
 154   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 155     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
 156       return ret;
 157
 158   memcpy (myaddr,
 159           (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 160           len);
 161
 162   return 0;
 163 }
 164
 165 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
 166 static int
 167 store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 168 {
 169   int i, ret;
 170
 171   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 172   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 173                / sizeof (PTRACE_TYPE_RET));
 174   PTRACE_TYPE_RET *buffer;
 175
 176   int tid = ptid_get_lwp (current_ptid);
 177
 178   buffer = XALLOCAVEC (PTRACE_TYPE_RET, count);
 179
 180   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 181     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
 182       return ret;
 183
 184   if (count > 1)
 185     if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
 186                                                * sizeof (PTRACE_TYPE_RET),
 187                                    &buffer[count - 1])) != 0)
 188       return ret;
 189
 190   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 191           myaddr, len);
 192
 193   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 194     if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
 195       return ret;
 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, CORE_ADDR *addr)
 206 {
 207   unsigned int insn;
 208   CORE_ADDR pc = fetch_ppc_register (32);  /* nip */
 209
 210   /* Fetch instruction preceding current NIP.  */
 211   if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
 212     return 0;
 213   /* It should be a "sc" instruction.  */
 214   if (insn != INSTR_SC)
 215     return 0;
 216   /* System call number should be NR_spu_run.  */
 217   if (fetch_ppc_register (0) != NR_spu_run)
 218     return 0;
 219
 220   /* Register 3 contains fd, register 4 the NPC param pointer.  */
 221   *fd = fetch_ppc_register (34);  /* orig_gpr3 */
 222   *addr = fetch_ppc_register (4);
 223   return 1;
 224 }
 225
 226
 227 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
 228    using the /proc file system.  */
 229 static int
 230 spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
 231                    const unsigned char *writebuf,
 232                    CORE_ADDR offset, int len)
 233 {
 234   char buf[128];
 235   int fd = 0;
 236   int ret = -1;
 237
 238   if (!annex)
 239     return 0;
 240
 241   sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
 242   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
 243   if (fd <= 0)
 244     return -1;
 245
 246   if (offset != 0
 247       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
 248     {
 249       close (fd);
 250       return 0;
 251     }
 252
 253   if (writebuf)
 254     ret = write (fd, writebuf, (size_t) len);
 255   else if (readbuf)
 256     ret = read (fd, readbuf, (size_t) len);
 257
 258   close (fd);
 259   return ret;
 260 }
 261
 262
 263 /* Start an inferior process and returns its pid.
 264    ALLARGS is a vector of program-name and args. */
 265 static int
 266 spu_create_inferior (char *program, char **allargs)
 267 {
 268   int pid;
 269   ptid_t ptid;
 270   struct process_info *proc;
 271
 272   pid = fork ();
 273   if (pid < 0)
 274     perror_with_name ("fork");
 275
 276   if (pid == 0)
 277     {
 278       close_most_fds ();
 279       ptrace (PTRACE_TRACEME, 0, 0, 0);
 280
 281       setpgid (0, 0);
 282
 283       execv (program, allargs);
 284       if (errno == ENOENT)
 285         execvp (program, allargs);
 286
 287       fprintf (stderr, "Cannot exec %s: %s.\n", program,
 288                strerror (errno));
 289       fflush (stderr);
 290       _exit (0177);
 291     }
 292
 293   proc = add_process (pid, 0);
 294   proc->tdesc = tdesc_spu;
 295
 296   ptid = ptid_build (pid, pid, 0);
 297   add_thread (ptid, NULL);
 298   return pid;
 299 }
 300
 301 /* Attach to an inferior process.  */
 302 int
 303 spu_attach (unsigned long  pid)
 304 {
 305   ptid_t ptid;
 306   struct process_info *proc;
 307
 308   if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
 309     {
 310       fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
 311                strerror (errno), errno);
 312       fflush (stderr);
 313       _exit (0177);
 314     }
 315
 316   proc = add_process (pid, 1);
 317   proc->tdesc = tdesc_spu;
 318   ptid = ptid_build (pid, pid, 0);
 319   add_thread (ptid, NULL);
 320   return 0;
 321 }
 322
 323 /* Kill the inferior process.  */
 324 static int
 325 spu_kill (int pid)
 326 {
 327   int status, ret;
 328   struct process_info *process = find_process_pid (pid);
 329   if (process == NULL)
 330     return -1;
 331
 332   ptrace (PTRACE_KILL, pid, 0, 0);
 333
 334   do {
 335     ret = waitpid (pid, &status, 0);
 336     if (WIFEXITED (status) || WIFSIGNALED (status))
 337       break;
 338   } while (ret != -1 || errno != ECHILD);
 339
 340   clear_inferiors ();
 341   remove_process (process);
 342   return 0;
 343 }
 344
 345 /* Detach from inferior process.  */
 346 static int
 347 spu_detach (int pid)
 348 {
 349   struct process_info *process = find_process_pid (pid);
 350   if (process == NULL)
 351     return -1;
 352
 353   ptrace (PTRACE_DETACH, 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 (int pid)
 368 {
 369   int status, ret;
 370
 371   do {
 372     ret = waitpid (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_equal (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 (ptid_equal (resume_info[i].thread, minus_one_ptid)
 394         || ptid_equal (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_get_lwp (ptid_of (thr)), 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_get_pid (ptid);
 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 pid_to_ptid (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 pid_to_ptid (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_build (ret, ret, 0);
 474     }
 475
 476   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 477   ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
 478   return ptid_build (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,  /* arch_setup */
 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, /* support_btrace */
 717   NULL, /* enable_btrace */
 718   NULL, /* disable_btrace */
 719   NULL, /* read_btrace */
 720   NULL, /* read_btrace_conf */
 721   NULL, /* supports_range_stepping */
 722   NULL, /* pid_to_exec_file */
 723   NULL, /* multifs_open */
 724   NULL, /* multifs_unlink */
 725   NULL, /* multifs_readlink */
 726   NULL, /* breakpoint_kind_from_pc */
 727   spu_sw_breakpoint_from_kind,
 728 };
 729
 730 void
 731 initialize_low (void)
 732 {
 733   set_target_ops (&spu_target_ops);
 734   init_registers_spu ();
 735 }