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