gdb/gdbserver/spu-low.c

   1 /* Low level interface to SPUs, for the remote server for GDB.
   2    Copyright (C) 2006-2014 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 <string.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29 #include <sys/syscall.h>
  30 #include "filestuff.h"
  31 #include "hostio.h"
  32
  33 /* Some older glibc versions do not define this.  */
  34 #ifndef __WNOTHREAD
  35 #define __WNOTHREAD     0x20000000      /* Don't wait on children of other
  36                                            threads in this group */
  37 #endif
  38
  39 #define PTRACE_TYPE_RET long
  40 #define PTRACE_TYPE_ARG3 long
  41
  42 /* Number of registers.  */
  43 #define SPU_NUM_REGS         130
  44 #define SPU_NUM_CORE_REGS    128
  45
  46 /* Special registers.  */
  47 #define SPU_ID_REGNUM        128
  48 #define SPU_PC_REGNUM        129
  49
  50 /* PPU side system calls.  */
  51 #define INSTR_SC        0x44000002
  52 #define NR_spu_run      0x0116
  53
  54 /* These are used in remote-utils.c.  */
  55 int using_threads = 0;
  56
  57 /* Defined in auto-generated file reg-spu.c.  */
  58 void init_registers_spu (void);
  59 extern const struct target_desc *tdesc_spu;
  60
  61 /* Fetch PPU register REGNO.  */
  62 static CORE_ADDR
  63 fetch_ppc_register (int regno)
  64 {
  65   PTRACE_TYPE_RET res;
  66
  67   int tid = ptid_get_lwp (current_ptid);
  68
  69 #ifndef __powerpc64__
  70   /* If running as a 32-bit process on a 64-bit system, we attempt
  71      to get the full 64-bit register content of the target process.
  72      If the PPC special ptrace call fails, we're on a 32-bit system;
  73      just fall through to the regular ptrace call in that case.  */
  74   {
  75     char buf[8];
  76
  77     errno = 0;
  78     ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  79             (PTRACE_TYPE_ARG3) (regno * 8), buf);
  80     if (errno == 0)
  81       ptrace (PPC_PTRACE_PEEKUSR_3264, tid,
  82               (PTRACE_TYPE_ARG3) (regno * 8 + 4), buf + 4);
  83     if (errno == 0)
  84       return (CORE_ADDR) *(unsigned long long *)buf;
  85   }
  86 #endif
  87
  88   errno = 0;
  89   res = ptrace (PT_READ_U, tid,
  90                 (PTRACE_TYPE_ARG3) (regno * sizeof (PTRACE_TYPE_RET)), 0);
  91   if (errno != 0)
  92     {
  93       char mess[128];
  94       sprintf (mess, "reading PPC register #%d", regno);
  95       perror_with_name (mess);
  96     }
  97
  98   return (CORE_ADDR) (unsigned long) res;
  99 }
 100
 101 /* Fetch WORD from PPU memory at (aligned) MEMADDR in thread TID.  */
 102 static int
 103 fetch_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET *word)
 104 {
 105   errno = 0;
 106
 107 #ifndef __powerpc64__
 108   if (memaddr >> 32)
 109     {
 110       unsigned long long addr_8 = (unsigned long long) memaddr;
 111       ptrace (PPC_PTRACE_PEEKTEXT_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 112     }
 113   else
 114 #endif
 115     *word = ptrace (PT_READ_I, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, 0);
 116
 117   return errno;
 118 }
 119
 120 /* Store WORD into PPU memory at (aligned) MEMADDR in thread TID.  */
 121 static int
 122 store_ppc_memory_1 (int tid, CORE_ADDR memaddr, PTRACE_TYPE_RET word)
 123 {
 124   errno = 0;
 125
 126 #ifndef __powerpc64__
 127   if (memaddr >> 32)
 128     {
 129       unsigned long long addr_8 = (unsigned long long) memaddr;
 130       ptrace (PPC_PTRACE_POKEDATA_3264, tid, (PTRACE_TYPE_ARG3) &addr_8, word);
 131     }
 132   else
 133 #endif
 134     ptrace (PT_WRITE_D, tid, (PTRACE_TYPE_ARG3) (size_t) memaddr, word);
 135
 136   return errno;
 137 }
 138
 139 /* Fetch LEN bytes of PPU memory at MEMADDR to MYADDR.  */
 140 static int
 141 fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 142 {
 143   int i, ret;
 144
 145   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 146   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 147                / sizeof (PTRACE_TYPE_RET));
 148   PTRACE_TYPE_RET *buffer;
 149
 150   int tid = ptid_get_lwp (current_ptid);
 151
 152   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 153   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 154     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
 155       return ret;
 156
 157   memcpy (myaddr,
 158           (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 159           len);
 160
 161   return 0;
 162 }
 163
 164 /* Store LEN bytes from MYADDR to PPU memory at MEMADDR.  */
 165 static int
 166 store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
 167 {
 168   int i, ret;
 169
 170   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 171   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 172                / sizeof (PTRACE_TYPE_RET));
 173   PTRACE_TYPE_RET *buffer;
 174
 175   int tid = ptid_get_lwp (current_ptid);
 176
 177   buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
 178
 179   if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 180     if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)
 181       return ret;
 182
 183   if (count > 1)
 184     if ((ret = fetch_ppc_memory_1 (tid, addr + (count - 1)
 185                                                * sizeof (PTRACE_TYPE_RET),
 186                                    &buffer[count - 1])) != 0)
 187       return ret;
 188
 189   memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 190           myaddr, len);
 191
 192   for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 193     if ((ret = store_ppc_memory_1 (tid, addr, buffer[i])) != 0)
 194       return ret;
 195
 196   return 0;
 197 }
 198
 199
 200 /* If the PPU thread is currently stopped on a spu_run system call,
 201    return to FD and ADDR the file handle and NPC parameter address
 202    used with the system call.  Return non-zero if successful.  */
 203 static int
 204 parse_spufs_run (int *fd, CORE_ADDR *addr)
 205 {
 206   unsigned int insn;
 207   CORE_ADDR pc = fetch_ppc_register (32);  /* nip */
 208
 209   /* Fetch instruction preceding current NIP.  */
 210   if (fetch_ppc_memory (pc-4, (char *) &insn, 4) != 0)
 211     return 0;
 212   /* It should be a "sc" instruction.  */
 213   if (insn != INSTR_SC)
 214     return 0;
 215   /* System call number should be NR_spu_run.  */
 216   if (fetch_ppc_register (0) != NR_spu_run)
 217     return 0;
 218
 219   /* Register 3 contains fd, register 4 the NPC param pointer.  */
 220   *fd = fetch_ppc_register (34);  /* orig_gpr3 */
 221   *addr = fetch_ppc_register (4);
 222   return 1;
 223 }
 224
 225
 226 /* Copy LEN bytes at OFFSET in spufs file ANNEX into/from READBUF or WRITEBUF,
 227    using the /proc file system.  */
 228 static int
 229 spu_proc_xfer_spu (const char *annex, unsigned char *readbuf,
 230                    const unsigned char *writebuf,
 231                    CORE_ADDR offset, int len)
 232 {
 233   char buf[128];
 234   int fd = 0;
 235   int ret = -1;
 236
 237   if (!annex)
 238     return 0;
 239
 240   sprintf (buf, "/proc/%ld/fd/%s", ptid_get_lwp (current_ptid), annex);
 241   fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
 242   if (fd <= 0)
 243     return -1;
 244
 245   if (offset != 0
 246       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
 247     {
 248       close (fd);
 249       return 0;
 250     }
 251
 252   if (writebuf)
 253     ret = write (fd, writebuf, (size_t) len);
 254   else if (readbuf)
 255     ret = read (fd, readbuf, (size_t) len);
 256
 257   close (fd);
 258   return ret;
 259 }
 260
 261
 262 /* Start an inferior process and returns its pid.
 263    ALLARGS is a vector of program-name and args. */
 264 static int
 265 spu_create_inferior (char *program, char **allargs)
 266 {
 267   int pid;
 268   ptid_t ptid;
 269   struct process_info *proc;
 270
 271   pid = fork ();
 272   if (pid < 0)
 273     perror_with_name ("fork");
 274
 275   if (pid == 0)
 276     {
 277       close_most_fds ();
 278       ptrace (PTRACE_TRACEME, 0, 0, 0);
 279
 280       setpgid (0, 0);
 281
 282       execv (program, allargs);
 283       if (errno == ENOENT)
 284         execvp (program, allargs);
 285
 286       fprintf (stderr, "Cannot exec %s: %s.\n", program,
 287                strerror (errno));
 288       fflush (stderr);
 289       _exit (0177);
 290     }
 291
 292   proc = add_process (pid, 0);
 293   proc->tdesc = tdesc_spu;
 294
 295   ptid = ptid_build (pid, pid, 0);
 296   add_thread (ptid, NULL);
 297   return pid;
 298 }
 299
 300 /* Attach to an inferior process.  */
 301 int
 302 spu_attach (unsigned long  pid)
 303 {
 304   ptid_t ptid;
 305   struct process_info *proc;
 306
 307   if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0)
 308     {
 309       fprintf (stderr, "Cannot attach to process %ld: %s (%d)\n", pid,
 310                strerror (errno), errno);
 311       fflush (stderr);
 312       _exit (0177);
 313     }
 314
 315   proc = add_process (pid, 1);
 316   proc->tdesc = tdesc_spu;
 317   ptid = ptid_build (pid, pid, 0);
 318   add_thread (ptid, NULL);
 319   return 0;
 320 }
 321
 322 /* Kill the inferior process.  */
 323 static int
 324 spu_kill (int pid)
 325 {
 326   int status, ret;
 327   struct process_info *process = find_process_pid (pid);
 328   if (process == NULL)
 329     return -1;
 330
 331   ptrace (PTRACE_KILL, pid, 0, 0);
 332
 333   do {
 334     ret = waitpid (pid, &status, 0);
 335     if (WIFEXITED (status) || WIFSIGNALED (status))
 336       break;
 337   } while (ret != -1 || errno != ECHILD);
 338
 339   clear_inferiors ();
 340   remove_process (process);
 341   return 0;
 342 }
 343
 344 /* Detach from inferior process.  */
 345 static int
 346 spu_detach (int pid)
 347 {
 348   struct process_info *process = find_process_pid (pid);
 349   if (process == NULL)
 350     return -1;
 351
 352   ptrace (PTRACE_DETACH, pid, 0, 0);
 353
 354   clear_inferiors ();
 355   remove_process (process);
 356   return 0;
 357 }
 358
 359 static void
 360 spu_mourn (struct process_info *process)
 361 {
 362   remove_process (process);
 363 }
 364
 365 static void
 366 spu_join (int pid)
 367 {
 368   int status, ret;
 369
 370   do {
 371     ret = waitpid (pid, &status, 0);
 372     if (WIFEXITED (status) || WIFSIGNALED (status))
 373       break;
 374   } while (ret != -1 || errno != ECHILD);
 375 }
 376
 377 /* Return nonzero if the given thread is still alive.  */
 378 static int
 379 spu_thread_alive (ptid_t ptid)
 380 {
 381   return ptid_equal (ptid, current_ptid);
 382 }
 383
 384 /* Resume process.  */
 385 static void
 386 spu_resume (struct thread_resume *resume_info, size_t n)
 387 {
 388   size_t i;
 389
 390   for (i = 0; i < n; i++)
 391     if (ptid_equal (resume_info[i].thread, minus_one_ptid)
 392         || ptid_equal (resume_info[i].thread, current_ptid))
 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_get_lwp (current_ptid), 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_get_pid (ptid);
 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 pid_to_ptid (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 pid_to_ptid (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_build (ret, ret, 0);
 472     }
 473
 474   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 475   ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
 476   return ptid_build (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   syscall (SYS_tkill, ptid_get_lwp (current_ptid), SIGINT);
 639 }
 640
 641 static struct target_ops spu_target_ops = {
 642   spu_create_inferior,
 643   spu_attach,
 644   spu_kill,
 645   spu_detach,
 646   spu_mourn,
 647   spu_join,
 648   spu_thread_alive,
 649   spu_resume,
 650   spu_wait,
 651   spu_fetch_registers,
 652   spu_store_registers,
 653   NULL, /* prepare_to_access_memory */
 654   NULL, /* done_accessing_memory */
 655   spu_read_memory,
 656   spu_write_memory,
 657   spu_look_up_symbols,
 658   spu_request_interrupt,
 659   NULL,
 660   NULL,  /* supports_z_point_type */
 661   NULL,
 662   NULL,
 663   NULL,
 664   NULL,
 665   NULL,
 666   NULL,
 667   spu_proc_xfer_spu,
 668   hostio_last_error_from_errno,
 669 };
 670
 671 void
 672 initialize_low (void)
 673 {
 674   static const unsigned char breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
 675
 676   set_target_ops (&spu_target_ops);
 677   set_breakpoint_data (breakpoint, sizeof breakpoint);
 678   init_registers_spu ();
 679 }