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   size_t i;
 387
 388   for (i = 0; i < n; i++)
 389     if (ptid_equal (resume_info[i].thread, minus_one_ptid)
 390         || ptid_equal (resume_info[i].thread, current_ptid))
 391       break;
 392
 393   if (i == n)
 394     return;
 395
 396   /* We don't support hardware single-stepping right now, assume
 397      GDB knows to use software single-stepping.  */
 398   if (resume_info[i].kind == resume_step)
 399     fprintf (stderr, "Hardware single-step not supported.\n");
 400
 401   regcache_invalidate ();
 402
 403   errno = 0;
 404   ptrace (PTRACE_CONT, ptid_get_lwp (current_ptid), 0, resume_info[i].sig);
 405   if (errno)
 406     perror_with_name ("ptrace");
 407 }
 408
 409 /* Wait for process, returns status.  */
 410 static ptid_t
 411 spu_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 412 {
 413   int pid = ptid_get_pid (ptid);
 414   int w;
 415   int ret;
 416
 417   while (1)
 418     {
 419       ret = waitpid (pid, &w, WNOHANG | __WALL | __WNOTHREAD);
 420
 421       if (ret == -1)
 422         {
 423           if (errno != ECHILD)
 424             perror_with_name ("waitpid");
 425         }
 426       else if (ret > 0)
 427         break;
 428
 429       usleep (1000);
 430     }
 431
 432   /* On the first wait, continue running the inferior until we are
 433      blocked inside an spu_run system call.  */
 434   if (!server_waiting)
 435     {
 436       int fd;
 437       CORE_ADDR addr;
 438
 439       while (!parse_spufs_run (&fd, &addr))
 440         {
 441           ptrace (PT_SYSCALL, pid, (PTRACE_TYPE_ARG3) 0, 0);
 442           waitpid (pid, NULL, __WALL | __WNOTHREAD);
 443         }
 444     }
 445
 446   if (WIFEXITED (w))
 447     {
 448       fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w));
 449       ourstatus->kind =  TARGET_WAITKIND_EXITED;
 450       ourstatus->value.integer = WEXITSTATUS (w);
 451       clear_inferiors ();
 452       return pid_to_ptid (ret);
 453     }
 454   else if (!WIFSTOPPED (w))
 455     {
 456       fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w));
 457       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 458       ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
 459       clear_inferiors ();
 460       return pid_to_ptid (ret);
 461     }
 462
 463   /* After attach, we may have received a SIGSTOP.  Do not return this
 464      as signal to GDB, or else it will try to continue with SIGSTOP ...  */
 465   if (!server_waiting)
 466     {
 467       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 468       ourstatus->value.sig = GDB_SIGNAL_0;
 469       return ptid_build (ret, ret, 0);
 470     }
 471
 472   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 473   ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
 474   return ptid_build (ret, ret, 0);
 475 }
 476
 477 /* Fetch inferior registers.  */
 478 static void
 479 spu_fetch_registers (struct regcache *regcache, int regno)
 480 {
 481   int fd;
 482   CORE_ADDR addr;
 483
 484   /* We must be stopped on a spu_run system call.  */
 485   if (!parse_spufs_run (&fd, &addr))
 486     return;
 487
 488   /* The ID register holds the spufs file handle.  */
 489   if (regno == -1 || regno == SPU_ID_REGNUM)
 490     supply_register (regcache, SPU_ID_REGNUM, (char *)&fd);
 491
 492   /* The NPC register is found at ADDR.  */
 493   if (regno == -1 || regno == SPU_PC_REGNUM)
 494     {
 495       char buf[4];
 496       if (fetch_ppc_memory (addr, buf, 4) == 0)
 497         supply_register (regcache, SPU_PC_REGNUM, buf);
 498     }
 499
 500   /* The GPRs are found in the "regs" spufs file.  */
 501   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
 502     {
 503       unsigned char buf[16*SPU_NUM_CORE_REGS];
 504       char annex[32];
 505       int i;
 506
 507       sprintf (annex, "%d/regs", fd);
 508       if (spu_proc_xfer_spu (annex, buf, NULL, 0, sizeof buf) == sizeof buf)
 509         for (i = 0; i < SPU_NUM_CORE_REGS; i++)
 510           supply_register (regcache, i, buf + i*16);
 511     }
 512 }
 513
 514 /* Store inferior registers.  */
 515 static void
 516 spu_store_registers (struct regcache *regcache, int regno)
 517 {
 518   int fd;
 519   CORE_ADDR addr;
 520
 521   /* ??? Some callers use 0 to mean all registers.  */
 522   if (regno == 0)
 523     regno = -1;
 524
 525   /* We must be stopped on a spu_run system call.  */
 526   if (!parse_spufs_run (&fd, &addr))
 527     return;
 528
 529   /* The NPC register is found at ADDR.  */
 530   if (regno == -1 || regno == SPU_PC_REGNUM)
 531     {
 532       char buf[4];
 533       collect_register (regcache, SPU_PC_REGNUM, buf);
 534       store_ppc_memory (addr, buf, 4);
 535     }
 536
 537   /* The GPRs are found in the "regs" spufs file.  */
 538   if (regno == -1 || (regno >= 0 && regno < SPU_NUM_CORE_REGS))
 539     {
 540       unsigned char buf[16*SPU_NUM_CORE_REGS];
 541       char annex[32];
 542       int i;
 543
 544       for (i = 0; i < SPU_NUM_CORE_REGS; i++)
 545         collect_register (regcache, i, buf + i*16);
 546
 547       sprintf (annex, "%d/regs", fd);
 548       spu_proc_xfer_spu (annex, NULL, buf, 0, sizeof buf);
 549     }
 550 }
 551
 552 /* Copy LEN bytes from inferior's memory starting at MEMADDR
 553    to debugger memory starting at MYADDR.  */
 554 static int
 555 spu_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 556 {
 557   int fd, ret;
 558   CORE_ADDR addr;
 559   char annex[32], lslr_annex[32], buf[32];
 560   CORE_ADDR lslr;
 561
 562   /* We must be stopped on a spu_run system call.  */
 563   if (!parse_spufs_run (&fd, &addr))
 564     return 0;
 565
 566   /* Use the "mem" spufs file to access SPU local store.  */
 567   sprintf (annex, "%d/mem", fd);
 568   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr, len);
 569   if (ret > 0)
 570     return ret == len ? 0 : EIO;
 571
 572   /* SPU local store access wraps the address around at the
 573      local store limit.  We emulate this here.  To avoid needing
 574      an extra access to retrieve the LSLR, we only do that after
 575      trying the original address first, and getting end-of-file.  */
 576   sprintf (lslr_annex, "%d/lslr", fd);
 577   memset (buf, 0, sizeof buf);
 578   if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
 579                          0, sizeof buf) <= 0)
 580     return ret;
 581
 582   lslr = strtoul (buf, NULL, 16);
 583   ret = spu_proc_xfer_spu (annex, myaddr, NULL, memaddr & lslr, len);
 584
 585   return ret == len ? 0 : EIO;
 586 }
 587
 588 /* Copy LEN bytes of data from debugger memory at MYADDR
 589    to inferior's memory at MEMADDR.
 590    On failure (cannot write the inferior)
 591    returns the value of errno.  */
 592 static int
 593 spu_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
 594 {
 595   int fd, ret;
 596   CORE_ADDR addr;
 597   char annex[32], lslr_annex[32], buf[32];
 598   CORE_ADDR lslr;
 599
 600   /* We must be stopped on a spu_run system call.  */
 601   if (!parse_spufs_run (&fd, &addr))
 602     return 0;
 603
 604   /* Use the "mem" spufs file to access SPU local store.  */
 605   sprintf (annex, "%d/mem", fd);
 606   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr, len);
 607   if (ret > 0)
 608     return ret == len ? 0 : EIO;
 609
 610   /* SPU local store access wraps the address around at the
 611      local store limit.  We emulate this here.  To avoid needing
 612      an extra access to retrieve the LSLR, we only do that after
 613      trying the original address first, and getting end-of-file.  */
 614   sprintf (lslr_annex, "%d/lslr", fd);
 615   memset (buf, 0, sizeof buf);
 616   if (spu_proc_xfer_spu (lslr_annex, (unsigned char *)buf, NULL,
 617                          0, sizeof buf) <= 0)
 618     return ret;
 619
 620   lslr = strtoul (buf, NULL, 16);
 621   ret = spu_proc_xfer_spu (annex, NULL, myaddr, memaddr & lslr, len);
 622
 623   return ret == len ? 0 : EIO;
 624 }
 625
 626 /* Look up special symbols -- unneded here.  */
 627 static void
 628 spu_look_up_symbols (void)
 629 {
 630 }
 631
 632 /* Send signal to inferior.  */
 633 static void
 634 spu_request_interrupt (void)
 635 {
 636   syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);
 637 }
 638
 639 static struct target_ops spu_target_ops = {
 640   spu_create_inferior,
 641   spu_attach,
 642   spu_kill,
 643   spu_detach,
 644   spu_mourn,
 645   spu_join,
 646   spu_thread_alive,
 647   spu_resume,
 648   spu_wait,
 649   spu_fetch_registers,
 650   spu_store_registers,
 651   NULL, /* prepare_to_access_memory */
 652   NULL, /* done_accessing_memory */
 653   spu_read_memory,
 654   spu_write_memory,
 655   spu_look_up_symbols,
 656   spu_request_interrupt,
 657   NULL,
 658   NULL,  /* supports_z_point_type */
 659   NULL,
 660   NULL,
 661   NULL, /* stopped_by_sw_breakpoint */
 662   NULL, /* supports_stopped_by_sw_breakpoint */
 663   NULL, /* stopped_by_hw_breakpoint */
 664   NULL, /* supports_stopped_by_hw_breakpoint */
 665   NULL, /* supports_conditional_breakpoints */
 666   NULL,
 667   NULL,
 668   NULL,
 669   NULL,
 670   spu_proc_xfer_spu,
 671   hostio_last_error_from_errno,
 672 };
 673
 674 void
 675 initialize_low (void)
 676 {
 677   static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
 678
 679   set_target_ops (&spu_target_ops);
 680   set_breakpoint_data (breakpoint, sizeof breakpoint);
 681   init_registers_spu ();
 682 }